diff --git a/docs/guide/infer.md b/docs/guide/infer.md
index d1543d58..684cd778 100644
--- a/docs/guide/infer.md
+++ b/docs/guide/infer.md
@@ -117,6 +117,67 @@ Replace the placeholder above through your configuration/secret-management
 workflow; omit `api_key` only when the target endpoint does not require
 authentication.
 
+### Google GenAI
+
+To call the native Gemini `generateContent` REST API, select the dialect
+explicitly and provide the Google AI endpoint and API key:
+
+```yaml
+models:
+  gemini:
+    name: gemini-3.8-flash
+    type: chat
+    dialect: google_genai
+    api_base: https://generativelanguage.googleapis.com
+    api_key: "<your Gemini API key>"
+```
+
+The model name may be `gemini-...` or `models/gemini-...`. An endpoint root
+uses `v1beta`; an explicit `/v1` or `/v1beta` suffix selects that version, and
+gateway path prefixes are preserved. The key is sent only in the
+`x-goog-api-key` header. Vertex AI resource paths and OAuth are not supported.
+
+Supported: text and image input, function tools, the `google_search` and
+`url_context` hosted tools, JSON output, thinking controls, logprobs,
+streaming, request seeds, and opaque continuation. Ordinary YAML bindings do
+not yet supply Google model-profile outcomes, so model-dependent capabilities
+(images, reasoning, tools, structured output, logprobs, opaque continuation)
+currently fail reconciliation with `model_outcome_missing`; plain text
+generation, streaming, seeds, and `dialect_options` work today.
+
+Rejected before any network I/O:
+
+- per-image `detail`, assistant prefill, input scoring,
+  `previous_response_id`, and `developer` messages (Google has no such role);
+- on `v1`, function schemas using constructs outside Google's OpenAPI subset
+  (`additionalProperties`, `$ref`, type arrays, numeric enums) — use `/v1beta`;
+  on both versions, a function needs a non-empty description and an explicit
+  `type: object` parameter root;
+- Gemini model-family limits, matched on the model name: on Gemini 3,
+  `sampling.n > 1`, explicit `temperature`/`top_p`/`top_k`, and
+  `reasoning.effort` values outside the model's
+  [thinking-level table](https://ai.google.dev/gemini-api/docs/generate-content/thinking);
+  on Gemini 2.5, `reasoning.effort` and out-of-range `reasoning.budget_tokens`;
+  on Gemini 1.x/2.x, mixing function tools with hosted tools. A gateway alias
+  that does not start with `gemini-` skips these checks.
+
+Provider-only root controls such as `safetySettings`, `serviceTier`, or `store`
+go through `dialect_options` (`cachedContent` and `labels` are `v1beta`-only).
+They cannot override `contents`, `generationConfig`, `tools`, `model`, or
+`stream`, and there is no HTTP-header passthrough.
+
+Accounting:
+
+- `MAX_TOKENS` and `CONTINUATION` keep the partial text and count toward
+  `n_truncated`. The dialect does not replay `continuationToken`; raise
+  `max_tokens` instead.
+- Candidate policy stops (`SAFETY`, `RECITATION`, …) count toward
+  `n_truncated`; a prompt blocked under `promptFeedback.blockReason` does not.
+  Both keep the raw reason, and `finish_reason_sources` records which it was.
+- `input_tokens` is `promptTokenCount + toolUsePromptTokenCount` and
+  `output_tokens` is `candidatesTokenCount + thoughtsTokenCount`, so
+  `reasoning_tokens` stays a breakdown of `output_tokens`.
+
 ## Environment Variables
 
 Custom environment variables can be passed through the YAML config's `infer.env` section. Values are injected into the inference engine process.
diff --git a/docs/guide/metrics.md b/docs/guide/metrics.md
index 391a607e..2b64cd17 100644
--- a/docs/guide/metrics.md
+++ b/docs/guide/metrics.md
@@ -509,12 +509,22 @@ at **every** budget, `n = 1` included, and by the single-draw tasks below that
 have no `n` at all. It measures the parser, not the draw, and `n = 1` is where a
 silently-stopped extractor survives longest: no second rollout to disagree with.
 
-`n_truncated` — **rollouts** whose generation stopped because it ran out of
-tokens rather than because the model was done — and `n_scored_rollouts`, the
-rollouts scored in total, are reported by **every `gen` task**, on the same terms
-as `n_unextracted`: they describe the generation rather than the draw, so neither
-is confined to `n > 1`. Unlike every other key here the *runner* injects them, so
-a task cannot report zero truncation by having forgotten to look.
+`n_truncated` — **rollouts** whose output was interrupted before completion,
+either by a token/context limit, output filtering, or refusal — and
+`n_scored_rollouts`, the rollouts scored in total, are reported by **every `gen`
+task**, on the same terms as `n_unextracted`: they describe the generation rather
+than the draw, so neither is confined to `n > 1`. Unlike every other key here
+the *runner* injects them, so a task cannot report zero truncation by having
+forgotten to look.
+
+What counts: token/context-limit stops (`length`, `max_tokens`,
+`max_output_tokens`, `model_context_window_exceeded`, Google `MAX_TOKENS` /
+`CONTINUATION`), OpenAI `content_filter`, Anthropic `refusal`, and Google
+candidate policy stops (`SAFETY`, `RECITATION`, `LANGUAGE`, …). A Google prompt
+block (`promptFeedback.blockReason`) does not count — no candidate was
+generated — and older Google records that lack `finish_reason_sources` cannot
+tell the two apart, so their policy stops are left uncounted. A Chat
+`message.refusal` without a `content_filter` finish reason is not counted.
 
 They arrive as a **pair or not at all**. The count alone says nothing about how
 much of a score it explains — `26` is a different fact at 600 rollouts than at 30
@@ -532,14 +542,11 @@ finals without per-stage metadata and a `0` would claim a clean run rather than
 unmeasured one. `sieval_versions` reports that state in band as `"unknown"`; a
 count has no such value.
 
-Read `n_truncated` as a **bound on how much of a score is budget, not
-capability** — a truncated rollout is scored wrong whether or not the model was
-on its way to the right answer, and the fix is `max_tokens`. It is independent of
-`n_unextracted`: an answer can be cut short and still parse (the truncation lands
-after the boxed answer), or parse cleanly and be wrong for reasons of its own.
-The two are worth reading together only in the direction where they coincide — a
-rollout that is both truncated *and* unextracted is the case where raising the
-budget is most likely to move the score.
+Read `n_truncated` as a count of interrupted outputs, **not** a budget-only
+diagnosis: raising `max_tokens` fixes only the token-limit stops, and the raw
+`finish_reasons` say which kind each was. It is independent of `n_unextracted` —
+an interrupted answer can still parse when the stop lands after the boxed
+answer — so when both occur, check the stop reason before changing the budget.
 
 ### Pairs that must be read together
 
diff --git a/sieval/core/models/__init__.py b/sieval/core/models/__init__.py
index 023d6a7e..a1d8e3df 100644
--- a/sieval/core/models/__init__.py
+++ b/sieval/core/models/__init__.py
@@ -46,6 +46,8 @@
 from .exceptions import CapabilityError
 from .gen_model import GenModel
 from .ir import (
+    FINISH_SOURCE_CANDIDATE,
+    FINISH_SOURCE_PROMPT_BLOCK,
     CapabilityEvidence,
     ChatInput,
     ChatMessage,
@@ -130,6 +132,8 @@
     "DialectOptions",
     "DialectSpec",
     "Engine",
+    "FINISH_SOURCE_CANDIDATE",
+    "FINISH_SOURCE_PROMPT_BLOCK",
     "FunctionToolCall",
     "GenModel",
     "GroundingChunk",
diff --git a/sieval/core/models/_legacy_bridge.py b/sieval/core/models/_legacy_bridge.py
index e0d1dd3f..10cc4176 100644
--- a/sieval/core/models/_legacy_bridge.py
+++ b/sieval/core/models/_legacy_bridge.py
@@ -77,6 +77,7 @@ class ModelCallMeta(TypedDict):
     usage: NotRequired[ModelUsage]
     request_params: NotRequired[dict[str, JSONValue]]
     finish_reasons: NotRequired[list[str]]
+    finish_reason_sources: NotRequired[list[str]]
     response_model: NotRequired[str]
     system_fingerprint: NotRequired[str | None]
 
@@ -101,6 +102,7 @@ class ModelOutput:
     request_params: dict[str, JSONValue] | None = None
     response_model: str | None = None
     system_fingerprint: str | None = None
+    finish_reason_sources: list[str] | None = None
 
 
 def _optional_float(value: object, name: str) -> float | None:
@@ -475,6 +477,11 @@ def response_to_model_output(model_meta: ModelMeta, response: Response) -> Model
             if response.finish_reasons is not None
             else None
         ),
+        finish_reason_sources=(
+            list(response.finish_reason_sources)
+            if response.finish_reason_sources is not None
+            else None
+        ),
         reasoning_texts=reasoning_texts,
         tool_calls=response.tool_calls,
         logprobs_tokens=logprobs_tokens,
diff --git a/sieval/core/models/dialect.py b/sieval/core/models/dialect.py
index b849445a..b3b5f477 100644
--- a/sieval/core/models/dialect.py
+++ b/sieval/core/models/dialect.py
@@ -13,7 +13,7 @@
 from copy import deepcopy
 from dataclasses import dataclass, fields
 from enum import StrEnum
-from typing import Protocol, cast, runtime_checkable
+from typing import TYPE_CHECKING, Protocol, cast, runtime_checkable
 
 from sieval.core.types import JSONValue
 
@@ -35,6 +35,9 @@
     response_field_contract,
 )
 
+if TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
 
 class DialectError(ValueError):
     """Base class for deterministic dialect contract failures."""
@@ -74,7 +77,31 @@ class WireVerifier(Protocol):
     def verify(self, body: Mapping[str, JSONValue]) -> str | None: ...
 
 
-type WireEvidence = WireObservation | WireVerifier
+class PreparedRequestVerifier(Protocol):
+    """Independently verify request evidence outside the JSON body."""
+
+    def verify_prepared(self, prepared: "PreparedRequest") -> str | None: ...
+
+
+@dataclass(frozen=True)
+class PreparedRequestEvidence:
+    """Opt a verifier into checking the whole prepared request, not just the body.
+
+    An explicit wrapper, so a ``WireVerifier`` never switches path by happening
+    to have a ``verify_prepared`` method.
+    """
+
+    verifier: PreparedRequestVerifier
+
+    def __post_init__(self) -> None:
+        if not callable(getattr(self.verifier, "verify_prepared", None)):
+            raise TypeError(
+                "PreparedRequestEvidence.verifier must provide callable "
+                "verify_prepared()"
+            )
+
+
+type WireEvidence = WireObservation | WireVerifier | PreparedRequestEvidence
 
 
 @dataclass(frozen=True)
@@ -220,7 +247,7 @@ def active_request_leaves(req: Request) -> dict[str, object]:
     """Return exact active semantic leaf paths for one concrete request."""
 
     active = _input_leaves(req)
-    grouped = {
+    grouped: dict[str, DataclassInstance] = {
         "sampling": req.sampling,
         "scoring": req.scoring,
         "reasoning": req.reasoning,
@@ -309,11 +336,14 @@ def consumed(self, path: str, *wire_evidence: WireEvidence) -> None:
             raise RequestAuditError(
                 f"consumed request leaf {path!r} requires wire evidence"
             )
-        if not all(
-            isinstance(evidence, (WireObservation, WireVerifier))
-            for evidence in wire_evidence
-        ):
-            raise TypeError("wire evidence must be WireObservation or WireVerifier")
+        for evidence in wire_evidence:
+            if isinstance(evidence, WireObservation | PreparedRequestEvidence):
+                continue
+            if not callable(getattr(evidence, "verify", None)):
+                raise TypeError(
+                    "wire evidence must be WireObservation, a verifier with "
+                    "callable verify(), or PreparedRequestEvidence"
+                )
         self._record(path, Consumed(path, tuple(wire_evidence)))
 
     def rejected(self, path: str, reason: str) -> None:
@@ -344,7 +374,7 @@ def finish(self, prepared: PreparedRequest) -> None:
                 "unaccounted request leaves: " + ", ".join(sorted(missing))
             )
 
-        verified: set[int] = set()
+        verified: set[tuple[str, int]] = set()
         for path, decision in self._decisions.items():
             if isinstance(decision, Consumed):
                 evidence_items = decision.wire_evidence
@@ -378,20 +408,39 @@ def finish(self, prepared: PreparedRequest) -> None:
                         )
                     continue
 
-                verifier_id = id(evidence)
+                verifier = (
+                    evidence.verifier
+                    if isinstance(evidence, PreparedRequestEvidence)
+                    else evidence
+                )
+                verifier_id = (
+                    "prepared"
+                    if isinstance(evidence, PreparedRequestEvidence)
+                    else "body",
+                    id(verifier),
+                )
                 if verifier_id in verified:
                     continue
                 verified.add(verifier_id)
-                mismatch = evidence.verify(prepared.body)
+                if isinstance(evidence, PreparedRequestEvidence):
+                    mismatch = evidence.verifier.verify_prepared(prepared)
+                else:
+                    verify = getattr(evidence, "verify", None)
+                    if not callable(verify):
+                        raise AssertionError(
+                            "admitted wire verifier lost its verify() method"
+                        )
+                    mismatch = verify(prepared.body)
                 if mismatch is not None and (
                     not isinstance(mismatch, str) or not mismatch.strip()
                 ):
                     raise TypeError(
-                        "WireVerifier.verify() must return None or a non-empty string"
+                        "request evidence verifier must return None or a non-empty "
+                        "string"
                     )
                 if mismatch is not None:
                     raise RequestAuditError(
-                        f"prepared wire mismatch for {path!r}: {mismatch}"
+                        f"prepared request evidence mismatch for {path!r}: {mismatch}"
                     )
 
 
@@ -606,9 +655,21 @@ class OutputRule:
 @dataclass(frozen=True)
 class OutputContract:
     rules: Mapping[str, OutputRule]
+    empty_outcome_finish_reasons: frozenset[str] = frozenset({"refusal"})
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "rules", dict(self.rules))
+        empty_outcome_finish_reasons = frozenset(self.empty_outcome_finish_reasons)
+        if not empty_outcome_finish_reasons or any(
+            not isinstance(reason, str) or not reason
+            for reason in empty_outcome_finish_reasons
+        ):
+            raise ValueError("empty-outcome finish reasons must be non-empty strings")
+        object.__setattr__(
+            self,
+            "empty_outcome_finish_reasons",
+            empty_outcome_finish_reasons,
+        )
         channels = {
             name
             for name, (role, _) in response_field_contract().items()
@@ -628,16 +689,18 @@ def validate(self, plan: RuntimePlanView, req: Request, response: Response) -> N
         # response channels this particular call must return.
         required = set(required_response_channels(req))
         finish_reasons = response.finish_reasons
-        refused = (
+        empty_outcome = (
             finish_reasons is not None
             and bool(finish_reasons)
-            and all(reason == "refusal" for reason in finish_reasons)
+            and all(
+                reason in self.empty_outcome_finish_reasons for reason in finish_reasons
+            )
         )
         for name, rule in self.rules.items():
             value = getattr(response, name)
             if rule.guarantee is Guarantee.NEVER and value is not None:
                 raise OutputContractError(f"dialect promised {name!r} would be absent")
-            if name in required and not refused:
+            if name in required and not empty_outcome:
                 if rule.guarantee is not Guarantee.PRESENT_OR_ERROR:
                     raise OutputContractError(
                         f"{name!r} is required but has {rule.guarantee.value} guarantee"
@@ -649,7 +712,7 @@ def validate(self, plan: RuntimePlanView, req: Request, response: Response) -> N
             if value is not None:
                 rule.validator(value)
 
-        if req.session.opaque_continuation is not None and not refused:
+        if req.session.opaque_continuation is not None and not empty_outcome:
             reasoning = response.reasoning
             if reasoning is None or any(
                 item is None
diff --git a/sieval/core/models/dialect_registry.py b/sieval/core/models/dialect_registry.py
index 9340eb34..b57ef5d6 100644
--- a/sieval/core/models/dialect_registry.py
+++ b/sieval/core/models/dialect_registry.py
@@ -34,6 +34,10 @@
     CAPABILITY_DECISIONS as ANTHROPIC_MESSAGES_CAPABILITY_DECISIONS,
 )
 from .dialects.anthropic_messages import AnthropicMessagesDialect
+from .dialects.google_genai import (
+    CAPABILITY_DECISIONS as GOOGLE_GENAI_CAPABILITY_DECISIONS,
+)
+from .dialects.google_genai import GoogleGenAIDialect
 from .dialects.openai_chat import (
     CAPABILITY_DECISIONS as OPENAI_CHAT_CAPABILITY_DECISIONS,
 )
@@ -329,6 +333,10 @@ def _bind_anthropic_messages(connection: Any, requested_model_id: str) -> Dialec
     return AnthropicMessagesDialect(connection, requested_model_id)
 
 
+def _bind_google_genai(connection: Any, requested_model_id: str) -> Dialect:
+    return GoogleGenAIDialect(connection, requested_model_id)
+
+
 def _binder(
     function: Callable[[Any, str], Dialect],
     decisions: Mapping[str, DialectCapabilityDecision],
@@ -370,6 +378,13 @@ def _binder(
                 ANTHROPIC_MESSAGES_CAPABILITY_DECISIONS,
             ),
         ),
+        "google_genai": _binder(
+            _bind_google_genai,
+            cast(
+                Mapping[str, DialectCapabilityDecision],
+                GOOGLE_GENAI_CAPABILITY_DECISIONS,
+            ),
+        ),
     }
 )
 
@@ -418,7 +433,8 @@ def _registered_decisions(
         "google_genai": _spec(
             "google_genai",
             "async_http_json",
-            request_seed_support=RequestSeedSupport.RESERVED,
+            decisions=_registered_decisions("google_genai"),
+            request_seed_support=RequestSeedSupport.SUPPORTED,
             input_kinds=("chat",),
             input_modalities=("text", "image", "tool_call", "tool_result"),
         ),
diff --git a/sieval/core/models/dialects/_google_genai_wire.py b/sieval/core/models/dialects/_google_genai_wire.py
new file mode 100644
index 00000000..2c559171
--- /dev/null
+++ b/sieval/core/models/dialects/_google_genai_wire.py
@@ -0,0 +1,383 @@
+"""Versioned GenerateContent routes and function-schema representations.
+
+Contracts follow Google's v1/v1beta Discovery revision 20260928:
+https://generativelanguage.googleapis.com/$discovery/rest?version=v1
+https://generativelanguage.googleapis.com/$discovery/rest?version=v1beta
+No runtime discovery or schema-key dropping is used. v1beta accepts both
+function schema forms; this adapter selects parametersJsonSchema to preserve
+the shared IR's JSON Schema. v1 requires the narrower Google Schema form.
+Lossless conversion preserves the supported schema's structure and constraints;
+annotations are carried unchanged, not promised to affect model generation.
+Google explicitly ignores default for validation. Its example documentation
+describes root population, not an explicit rejection of nested input examples.
+
+AI-Generated Code - GPT-6 (OpenAI)
+"""
+
+import math
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Literal, cast
+
+import httpx
+
+from sieval.core.models._shared import copy_json_value
+from sieval.core.models.dialect import DialectError
+from sieval.core.types import JSONValue
+
+
+@dataclass(frozen=True)
+class GoogleWireContract:
+    api_version: Literal["v1", "v1beta"]
+    function_schema_field: Literal["parameters", "parametersJsonSchema"]
+    unavailable_fields: Mapping[str, frozenset[str]]
+
+
+_V1_UNAVAILABLE_FIELDS = MappingProxyType(
+    {
+        "request": frozenset({"cachedContent", "labels"}),
+        "generationConfig": frozenset(
+            {
+                "audioTranscriptionConfig",
+                "enableAffectiveDialog",
+                "speechConfig",
+                "translationConfig",
+            }
+        ),
+        "tool": frozenset({"computerUse", "mcpServers"}),
+        "functionDeclaration": frozenset(
+            {"behavior", "parametersJsonSchema", "responseJsonSchema"}
+        ),
+        "part": frozenset({"audioTranscription", "speechMetadata"}),
+        "functionResponse": frozenset({"parts", "scheduling", "willContinue"}),
+        "inlineData": frozenset({"displayName"}),
+        "fileData": frozenset({"displayName"}),
+    }
+)
+GOOGLE_WIRE_CONTRACTS: Mapping[str, GoogleWireContract] = MappingProxyType(
+    {
+        "v1": GoogleWireContract("v1", "parameters", _V1_UNAVAILABLE_FIELDS),
+        "v1beta": GoogleWireContract(
+            "v1beta", "parametersJsonSchema", MappingProxyType({})
+        ),
+    }
+)
+
+
+def resolve_wire_endpoint(base_url: httpx.URL) -> tuple[GoogleWireContract, httpx.URL]:
+    """Resolve a root or versioned gateway URL without mutating its client."""
+
+    if base_url.query or base_url.fragment:
+        raise ValueError("Google api_base must not contain query data or fragments")
+    path = base_url.path.rstrip("/")
+    segments = path.split("/")
+    # Only the terminal segment selects the Google API version. Earlier
+    # version-like segments may belong to a gateway's own routing scheme.
+    if "models" in segments or (
+        segments[-1] not in GOOGLE_WIRE_CONTRACTS
+        and re.match(r"v[0-9]", segments[-1], re.IGNORECASE)
+    ):
+        raise ValueError(
+            "Google api_base must be an endpoint root or end in /v1 or /v1beta"
+        )
+    version = "v1beta"
+    if segments[-1] in GOOGLE_WIRE_CONTRACTS:
+        version = segments.pop()
+        path = "/".join(segments)
+    return GOOGLE_WIRE_CONTRACTS[version], base_url.copy_with(path=f"{path}/")
+
+
+_SCHEMA_TYPES = frozenset(
+    {"string", "number", "integer", "boolean", "array", "object", "null"}
+)
+_SCHEMA_STRINGS = frozenset({"title", "description", "format", "pattern"})
+_SCHEMA_COUNTS = frozenset(
+    {"minItems", "maxItems", "minLength", "maxLength", "minProperties", "maxProperties"}
+)
+_SCHEMA_NUMBERS = frozenset({"minimum", "maximum"})
+_SCHEMA_STRING_LISTS = frozenset({"required", "propertyOrdering", "enum"})
+_SCHEMA_KEYS = (
+    _SCHEMA_STRINGS
+    | _SCHEMA_COUNTS
+    | _SCHEMA_NUMBERS
+    | _SCHEMA_STRING_LISTS
+    | {"type", "properties", "items", "anyOf", "nullable", "default", "example"}
+)
+_INT64_MAX = 2**63 - 1
+
+
+def validate_function_parameters(raw: object) -> None:
+    """Require an explicit object root for function arguments, not results.
+
+    This is SiEval's conservative admission rule for Google's object-schema
+    requirement. It does not infer the root type from refs or composition, nor
+    rewrite a schema to insert a type. Omitting parameters entirely is valid.
+    """
+
+    if (
+        not isinstance(raw, Mapping)
+        or cast(Mapping[str, object], raw).get("type") != "object"
+    ):
+        raise DialectError(
+            "Google function parameters must describe an object with explicit "
+            "type: object"
+        )
+
+
+def _schema_object(raw: object, path: str) -> dict[str, JSONValue]:
+    if not isinstance(raw, Mapping):
+        raise DialectError(f"{path}: Google v1 Schema requires an object")
+    try:
+        copied = copy_json_value(raw, path)
+    except (TypeError, ValueError) as exc:
+        raise DialectError(f"{path}: invalid Google v1 Schema: {exc}") from exc
+    assert isinstance(copied, dict)
+    unsupported = set(copied) - _SCHEMA_KEYS
+    if unsupported:
+        raise DialectError(
+            f"{path}: Google v1 Schema cannot represent keyword(s) "
+            f"{', '.join(sorted(unsupported))}; use /v1beta for JSON Schema"
+        )
+    return dict(copied)
+
+
+def _check_scalar(schema: Mapping[str, JSONValue], key: str, path: str) -> None:
+    value = schema[key]
+    if key in _SCHEMA_STRINGS and not isinstance(value, str):
+        raise DialectError(f"{path}.{key}: Google v1 Schema requires a string")
+    if key == "nullable" and not isinstance(value, bool):
+        raise DialectError(f"{path}.{key}: Google v1 Schema requires a boolean")
+    if key in _SCHEMA_NUMBERS:
+        try:
+            exact = (
+                isinstance(value, (int, float))
+                and not isinstance(value, bool)
+                and math.isfinite(value)
+                and float(value) == value
+            )
+        except OverflowError:
+            exact = False
+        if not exact:
+            raise DialectError(
+                f"{path}.{key}: Google v1 Schema requires an exactly representable "
+                "finite double"
+            )
+    if key in _SCHEMA_STRING_LISTS:
+        if not isinstance(value, list) or any(not isinstance(x, str) for x in value):
+            raise DialectError(f"{path}.{key}: Google v1 Schema requires strings")
+        if len(value) != len(set(cast(list[str], value))):
+            raise DialectError(
+                f"{path}.{key}: Google v1 Schema requires unique strings"
+            )
+        if key == "enum" and not value:
+            raise DialectError(
+                f"{path}.enum: Google v1 Schema requires a non-empty enum"
+            )
+
+
+def lower_function_schema(
+    raw: object, path: str = "tools.functions.parameters"
+) -> dict[str, JSONValue]:
+    """Encode a lossless subset, requiring an explicit type on every node."""
+
+    source = _schema_object(raw, path)
+    type_name = source.get("type")
+    if not isinstance(type_name, str) or type_name not in _SCHEMA_TYPES:
+        raise DialectError(
+            f"{path}.type: Google v1 Schema requires a single explicit JSON Schema type"
+        )
+    result: dict[str, JSONValue] = {"type": type_name.upper()}
+    for key, value in source.items():
+        if key == "type":
+            continue
+        if key in _SCHEMA_COUNTS:
+            if (
+                isinstance(value, bool)
+                or not isinstance(value, int)
+                or not 0 <= value <= _INT64_MAX
+            ):
+                raise DialectError(
+                    f"{path}.{key}: Google v1 Schema requires a non-negative int64"
+                )
+            result[key] = str(value)
+        elif key == "properties":
+            if not isinstance(value, Mapping):
+                raise DialectError(
+                    f"{path}.properties: Google v1 Schema requires an object"
+                )
+            property_schemas: dict[str, JSONValue] = {}
+            for name, child in value.items():
+                assert isinstance(name, str)  # _schema_object checked JSON keys.
+                property_schemas[name] = lower_function_schema(
+                    child, f"{path}.properties.{name}"
+                )
+            result[key] = property_schemas
+        elif key == "items":
+            result[key] = lower_function_schema(value, f"{path}.items")
+        elif key == "anyOf":
+            if not isinstance(value, list) or not value:
+                raise DialectError(
+                    f"{path}.anyOf: Google v1 Schema requires a non-empty array"
+                )
+            result[key] = [
+                lower_function_schema(child, f"{path}.anyOf[{index}]")
+                for index, child in enumerate(value)
+            ]
+        else:
+            _check_scalar(source, key, path)
+            if key == "enum" and type_name != "string":
+                raise DialectError(
+                    f"{path}.enum: Google v1 Schema only maps string enums"
+                )
+            result[key] = value
+    return result
+
+
+def inspect_function_schema(
+    raw: object, path: str = "final function parameters"
+) -> dict[str, JSONValue]:
+    """Decode the actual v1 wire form independently of request lowering.
+
+    The audit compares this result to the original JSON Schema. Calling the
+    encoder here would let an encoder mutation also rewrite its own oracle.
+    Only schema nodes are traversed; annotation values and property names are
+    opaque, even when they happen to contain keys such as ``type``.
+    """
+
+    wire = _schema_object(raw, path)
+    wire_type = wire.get("type")
+    if not isinstance(wire_type, str) or wire_type not in {
+        "STRING",
+        "NUMBER",
+        "INTEGER",
+        "BOOLEAN",
+        "ARRAY",
+        "OBJECT",
+        "NULL",
+    }:
+        raise DialectError(
+            f"{path}.type: Google v1 wire Schema requires an uppercase type"
+        )
+    decoded: dict[str, JSONValue] = {}
+    for name, value in wire.items():
+        if name == "type":
+            decoded[name] = wire_type.lower()
+        elif name in _SCHEMA_COUNTS:
+            if (
+                not isinstance(value, str)
+                or re.fullmatch(r"0|[1-9][0-9]{0,18}", value) is None
+            ):
+                raise DialectError(
+                    f"{path}.{name}: Google v1 wire Schema requires an int64 string"
+                )
+            count = int(value)
+            if count > _INT64_MAX:
+                raise DialectError(
+                    f"{path}.{name}: Google v1 wire Schema int64 is out of range"
+                )
+            decoded[name] = count
+        elif name == "properties":
+            if not isinstance(value, Mapping):
+                raise DialectError(
+                    f"{path}.properties: Google v1 wire Schema requires an object"
+                )
+            properties: dict[str, JSONValue] = {}
+            for property_name, property_schema in value.items():
+                assert isinstance(
+                    property_name, str
+                )  # _schema_object checked JSON keys.
+                properties[property_name] = inspect_function_schema(
+                    property_schema, f"{path}.properties.{property_name}"
+                )
+            decoded[name] = properties
+        elif name == "items":
+            decoded[name] = inspect_function_schema(value, f"{path}.items")
+        elif name == "anyOf":
+            if not isinstance(value, list) or not value:
+                raise DialectError(
+                    f"{path}.anyOf: Google v1 wire Schema requires a non-empty array"
+                )
+            decoded[name] = [
+                inspect_function_schema(child, f"{path}.anyOf[{index}]")
+                for index, child in enumerate(value)
+            ]
+        else:
+            _check_scalar(wire, name, path)
+            if name == "enum" and wire_type != "STRING":
+                raise DialectError(
+                    f"{path}.enum: Google v1 wire Schema only maps string enums"
+                )
+            decoded[name] = value
+    return decoded
+
+
+def validate_wire_body(
+    body: Mapping[str, JSONValue], contract: GoogleWireContract
+) -> None:
+    """Validate versioned fields and parameter roots at actual schema locations.
+
+    Free-form JSON (function arguments, results, annotations, JSON Schema)
+    must not be searched by key name: a user may legitimately name a property
+    ``cachedContent`` or ``parametersJsonSchema``.
+    """
+
+    def check(raw: object, shape: str, path: str) -> None:
+        if isinstance(raw, Mapping):
+            forbidden = contract.unavailable_fields.get(shape, frozenset()) & raw.keys()
+            if forbidden:
+                raise DialectError(
+                    f"{path}: field(s) {', '.join(sorted(forbidden))} are unavailable "
+                    f"in Google {contract.api_version}"
+                )
+
+    def sequence(raw: object) -> Sequence[object]:
+        return (
+            raw
+            if isinstance(raw, Sequence) and not isinstance(raw, str | bytes)
+            else ()
+        )
+
+    check(body, "request", "request")
+    check(body.get("generationConfig"), "generationConfig", "generationConfig")
+    for index, tool in enumerate(sequence(body.get("tools"))):
+        check(tool, "tool", f"tools[{index}]")
+        if not isinstance(tool, Mapping):
+            continue
+        tool_mapping = cast(Mapping[str, JSONValue], tool)
+        for declaration in sequence(tool_mapping.get("functionDeclarations")):
+            check(
+                declaration,
+                "functionDeclaration",
+                f"tools[{index}].functionDeclarations",
+            )
+            if not isinstance(declaration, Mapping):
+                continue
+            declaration_mapping = cast(Mapping[str, JSONValue], declaration)
+            for field in ("parameters", "response"):
+                if field in declaration and f"{field}JsonSchema" in declaration:
+                    raise DialectError(
+                        f"{field} and {field}JsonSchema are mutually exclusive"
+                    )
+                if field in declaration:
+                    schema = inspect_function_schema(
+                        declaration_mapping[field], f"function.{field}"
+                    )
+                    if field == "parameters":
+                        validate_function_parameters(schema)
+            if "parametersJsonSchema" in declaration:
+                validate_function_parameters(
+                    declaration_mapping["parametersJsonSchema"]
+                )
+    for content in (*sequence(body.get("contents")), body.get("systemInstruction")):
+        if not isinstance(content, Mapping):
+            continue
+        content_mapping = cast(Mapping[str, JSONValue], content)
+        for part in sequence(content_mapping.get("parts")):
+            if not isinstance(part, Mapping):
+                continue
+            check(part, "part", "contents.parts")
+            part_mapping = cast(Mapping[str, JSONValue], part)
+            for field in ("functionResponse", "inlineData", "fileData"):
+                check(part_mapping.get(field), field, f"contents.parts.{field}")
diff --git a/sieval/core/models/dialects/google_genai.py b/sieval/core/models/dialects/google_genai.py
new file mode 100644
index 00000000..0ac3571a
--- /dev/null
+++ b/sieval/core/models/dialects/google_genai.py
@@ -0,0 +1,3821 @@
+"""Google Gemini native ``generateContent`` dialect for the model IR.
+
+The adapter speaks the public REST protocol through the provider-neutral
+``async_http_json`` connection.  Request leaves are translated only where the
+shared IR has a lossless Google representation; provider-only controls remain
+audited dialect options and ambiguous response shapes fail loudly.
+
+AI-Generated Code - GPT-5.6 (OpenAI)
+"""
+
+import hashlib
+import json
+import math
+import re
+from collections.abc import Callable, Mapping, Sequence
+from copy import deepcopy
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from types import MappingProxyType
+from typing import cast
+from urllib.parse import quote
+
+import httpx
+
+from sieval.core.models._shared import copy_json_value
+from sieval.core.models.capabilities import (
+    CAPABILITY_KEYS,
+    Capability,
+    CapabilityKey,
+    DialectCapabilityBinding,
+    DialectCapabilityDecision,
+    HostedToolsOptions,
+    MultimodalInputOptions,
+    ReasoningOptions,
+    Supported,
+    TopLogprobsOptions,
+    Unsupported,
+)
+from sieval.core.models.connection_factory import AsyncHTTPJSONConnection
+from sieval.core.models.deployment import BINDING_RESOURCE_KEYS
+from sieval.core.models.dialect import (
+    DialectError,
+    Guarantee,
+    OutputContract,
+    OutputContractError,
+    OutputRule,
+    PreparedRequest,
+    PreparedRequestEvidence,
+    RequestAudit,
+    RuntimePlanView,
+    WireEvidence,
+    WireObservation,
+    active_request_leaves,
+    validate_reasoning,
+    validate_request_invariants,
+    validate_runtime_binding_plan,
+    validate_structured_output,
+    validate_tool_calls,
+    validate_top_logprobs,
+)
+from sieval.core.models.ir import (
+    FINISH_SOURCE_CANDIDATE,
+    FINISH_SOURCE_PROMPT_BLOCK,
+    ChatInput,
+    ChatMessage,
+    Citation,
+    FunctionToolCall,
+    GroundingChunk,
+    GroundingMetadata,
+    ImagePart,
+    ReasoningOutput,
+    Request,
+    Response,
+    ServerToolUse,
+    StructuredOutput,
+    TextPart,
+    TokenLogprob,
+    ToolCallPart,
+    ToolResultPart,
+    TopKEntry,
+    UsageStats,
+)
+from sieval.core.types import JSONValue
+
+from ._google_genai_wire import (
+    GoogleWireContract,
+    inspect_function_schema,
+    lower_function_schema,
+    resolve_wire_endpoint,
+    validate_function_parameters,
+    validate_wire_body,
+)
+
+_THINKING_LEVELS = frozenset({"minimal", "low", "medium", "high"})
+_HOSTED_TOOL_KINDS = frozenset({"google_search", "url_context"})
+_IMAGE_MEDIA_TYPES = frozenset(
+    {
+        "image/avif",
+        "image/gif",
+        "image/heic",
+        "image/heif",
+        "image/jpeg",
+        "image/jpg",
+        "image/png",
+        "image/webp",
+    }
+)
+_OPAQUE_VERSION = 1
+_INT32_MIN = -(2**31)
+_INT32_MAX = 2**31 - 1
+_CHAT_ROLES = frozenset({"system", "developer", "user", "assistant", "tool"})
+_FUNCTION_NAME_PATTERN = re.compile(r"[A-Za-z0-9_:.\-]{1,128}")
+_RFC3339_TIMESTAMP_PATTERN = re.compile(
+    r"(?P<date>\d{4}-\d{2}-\d{2})T"
+    r"(?P<time>\d{2}:\d{2}:\d{2})"
+    r"(?:\.(?P<fraction>\d{1,9}))?"
+    r"(?P<offset>Z|[+\-]\d{2}:\d{2})"
+)
+# Keep these family rows aligned with Google's public thinking table and
+# current-model migration guide; request validation must not infer support from
+# the presence of a protocol field alone.
+_GEMINI_3_MODEL_PATTERN = re.compile(r"gemini-3(?:[.\-]|$)")
+_GEMINI_PRE_3_MODEL_PATTERN = re.compile(r"gemini-[12](?:[.\-]|$)")
+_GEMINI_25_PRO_PATTERN = re.compile(r"gemini-2\.5-pro(?:[.\-]|$)")
+_GEMINI_25_FLASH_LITE_PATTERN = re.compile(r"gemini-2\.5-flash-lite(?:[.\-]|$)")
+_GEMINI_25_FLASH_PATTERN = re.compile(r"gemini-2\.5-flash(?:[.\-]|$)")
+_GEMINI_31_FLASH_LITE_IMAGE_PATTERN = re.compile(
+    r"gemini-3\.1-flash-lite-image(?:[.\-]|$)"
+)
+_GEMINI_31_PRO_PATTERN = re.compile(r"gemini-3\.1-pro(?:[.\-]|$)")
+_GEMINI_31_FLASH_LITE_PATTERN = re.compile(r"gemini-3\.1-flash-lite(?:[.\-]|$)")
+_GEMINI_35_36_FLASH_PATTERN = re.compile(r"gemini-3\.(?:5|6)-flash(?:[.\-]|$)")
+_GEMINI_37_38_FLASH_PATTERN = re.compile(r"gemini-3\.(?:7|8)-flash(?:[.\-]|$)")
+_GEMINI_3_FLASH_PATTERN = re.compile(r"gemini-3-flash(?:[.\-]|$)")
+_GEMINI_3_PRO_PREVIEW_PATTERN = re.compile(r"gemini-3-pro-preview(?:[.\-]|$)")
+_GEMINI_3_SAMPLING_PATHS = frozenset(
+    {"sampling.temperature", "sampling.top_p", "sampling.top_k"}
+)
+_GEMINI_3_SAMPLING_WIRE_KEYS = frozenset({"temperature", "topP", "topK"})
+_STANDARD_USER_PART_FIELDS = frozenset({"text", "inlineData", "fileData"})
+#: Finish reasons that may leave requested channels empty. ``CONTINUATION``
+#: carries a ``continuationToken`` this dialect does not replay; like
+#: ``MAX_TOKENS`` it counts as truncated.
+_CHANNEL_OPTIONAL_FINISH_REASONS = frozenset(
+    {
+        "MAX_TOKENS",
+        "CONTINUATION",
+        "SAFETY",
+        "RECITATION",
+        "LANGUAGE",
+        "OTHER",
+        "BLOCKLIST",
+        "PROHIBITED_CONTENT",
+        "SPII",
+        "MALFORMED_FUNCTION_CALL",
+        "IMAGE_SAFETY",
+        "IMAGE_PROHIBITED_CONTENT",
+        "IMAGE_OTHER",
+        "NO_IMAGE",
+        "IMAGE_RECITATION",
+        "UNEXPECTED_TOOL_CALL",
+        "TOO_MANY_TOOL_CALLS",
+        "MALFORMED_RESPONSE",
+        "ESCALATION",
+    }
+)
+
+
+@dataclass(frozen=True)
+class _GoogleModelRequestConstraints:
+    """Documented request domains for one Google model family.
+
+    ``thinking_levels=None`` means the current Google documentation does not
+    publish a narrower level table for the model id.  An empty set means the
+    family does not support ``thinkingLevel`` at all.
+    """
+
+    thinking_levels: frozenset[str] | None = None
+    positive_thinking_budget_range: tuple[int, int] | None = None
+    omit_sampling_controls: bool = False
+    maximum_candidates: int | None = None
+    mixed_tools_supported: bool | None = None
+
+
+def _model_request_constraints(model_name: str) -> _GoogleModelRequestConstraints:
+    """Resolve Google-documented constraints without scattering model checks."""
+
+    if _GEMINI_25_PRO_PATTERN.match(model_name):
+        return _GoogleModelRequestConstraints(
+            thinking_levels=frozenset(),
+            positive_thinking_budget_range=(128, 32768),
+            mixed_tools_supported=False,
+        )
+    if _GEMINI_25_FLASH_LITE_PATTERN.match(model_name):
+        return _GoogleModelRequestConstraints(
+            thinking_levels=frozenset(),
+            positive_thinking_budget_range=(512, 24576),
+            mixed_tools_supported=False,
+        )
+    if _GEMINI_25_FLASH_PATTERN.match(model_name):
+        # Google also accepts 0 to disable thinking, but the shared IR keeps
+        # disablement separate from its positive token-budget field.
+        return _GoogleModelRequestConstraints(
+            thinking_levels=frozenset(),
+            positive_thinking_budget_range=(1, 24576),
+            mixed_tools_supported=False,
+        )
+
+    if not _GEMINI_3_MODEL_PATTERN.match(model_name):
+        return _GoogleModelRequestConstraints(
+            mixed_tools_supported=(
+                False if _GEMINI_PRE_3_MODEL_PATTERN.match(model_name) else None
+            )
+        )
+
+    levels: frozenset[str] | None = None
+    if _GEMINI_31_FLASH_LITE_IMAGE_PATTERN.match(model_name):
+        levels = frozenset({"minimal", "high"})
+    elif _GEMINI_31_PRO_PATTERN.match(model_name):
+        levels = frozenset({"low", "medium", "high"})
+    elif _GEMINI_3_PRO_PREVIEW_PATTERN.match(model_name):
+        levels = frozenset({"low", "high"})
+    elif (
+        _GEMINI_31_FLASH_LITE_PATTERN.match(model_name)
+        or _GEMINI_35_36_FLASH_PATTERN.match(model_name)
+        or _GEMINI_3_FLASH_PATTERN.match(model_name)
+    ):
+        levels = _THINKING_LEVELS
+    elif _GEMINI_37_38_FLASH_PATTERN.match(model_name):
+        levels = frozenset({"low", "medium", "high"})
+
+    return _GoogleModelRequestConstraints(
+        thinking_levels=levels,
+        omit_sampling_controls=True,
+        maximum_candidates=1,
+        mixed_tools_supported=True,
+    )
+
+
+def _requires_exact_function_call_ids(model_name: str) -> bool:
+    """Return whether Google guarantees provider-issued function call IDs."""
+
+    return _GEMINI_3_MODEL_PATTERN.match(model_name) is not None
+
+
+_FATAL_FINISH_REASON_MESSAGES = MappingProxyType(
+    {
+        "MISSING_THOUGHT_SIGNATURE": (
+            "Google rejected the request because continuation history omitted a "
+            "required thought signature"
+        ),
+        "PUP_LIMITED_DISABLED": (
+            "Google stopped generation because the account is limited or disabled "
+            "by Prohibited Use Policy"
+        ),
+    }
+)
+_IR_OWNED_KEYS = BINDING_RESOURCE_KEYS | frozenset(
+    {
+        "model",
+        "contents",
+        "systemInstruction",
+        "generationConfig",
+        "tools",
+        "toolConfig",
+        "stream",
+    }
+)
+
+
+def _reject_json_constant(value: str) -> None:
+    raise ValueError(f"non-finite JSON constant {value!r}")
+
+
+def _reject_duplicate_keys(
+    pairs: list[tuple[str, JSONValue]],
+) -> dict[str, JSONValue]:
+    result: dict[str, JSONValue] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError(f"duplicate JSON key {key!r}")
+        result[key] = value
+    return result
+
+
+def _strict_json_loads(payload: str, path: str) -> JSONValue:
+    try:
+        return cast(
+            JSONValue,
+            json.loads(
+                payload,
+                object_pairs_hook=_reject_duplicate_keys,
+                parse_constant=_reject_json_constant,
+            ),
+        )
+    except (json.JSONDecodeError, TypeError, ValueError) as exc:
+        raise OutputContractError(f"{path} is not strict JSON") from exc
+
+
+def _tuple_validator(item_type: type, channel: str) -> Callable[[object], None]:
+    def validate(value: object) -> None:
+        if not isinstance(value, tuple) or not all(
+            isinstance(item, item_type) for item in value
+        ):
+            raise OutputContractError(f"{channel} channel has invalid shape")
+
+    return validate
+
+
+def _validate_top_logprobs_config(options: object) -> None:
+    assert isinstance(options, TopLogprobsOptions)
+    if options.minimum > 20:
+        raise ValueError("google_genai supports at most 20 top logprobs")
+
+
+def _validate_reasoning_config(options: object) -> None:
+    assert isinstance(options, ReasoningOptions)
+    if options.summary not in {None, "none", "auto"}:
+        raise ValueError(
+            "google_genai supports only reasoning summary 'none' or 'auto'"
+        )
+    if options.effort is not None and options.effort.lower() not in _THINKING_LEVELS:
+        raise ValueError(f"unsupported Google thinking level {options.effort!r}")
+
+
+def _validate_hosted_tools_config(options: object) -> None:
+    assert isinstance(options, HostedToolsOptions)
+    unsupported = set(options.kinds) - _HOSTED_TOOL_KINDS
+    if unsupported:
+        raise ValueError(
+            "google_genai supports only google_search and url_context hosted tools; "
+            f"unsupported kinds: {sorted(unsupported)}"
+        )
+
+
+def _validate_multimodal_config(options: object) -> None:
+    assert isinstance(options, MultimodalInputOptions)
+    unsupported = set(options.modalities) - {"image"}
+    if unsupported:
+        raise ValueError(f"google_genai does not support modalities {unsupported!r}")
+
+
+def _decisions() -> Mapping[CapabilityKey, DialectCapabilityDecision]:
+    decisions: dict[CapabilityKey, DialectCapabilityDecision] = {
+        "input_scoring": Unsupported(
+            "Gemini generateContent cannot score input tokens"
+        ),
+        "sampled_logprobs": Supported(
+            DialectCapabilityBinding(
+                "sampled_logprobs",
+                request_leaves=("scoring.sampled_logprobs",),
+                response_channels=("logprobs",),
+            )
+        ),
+        "top_logprobs": Supported(
+            DialectCapabilityBinding(
+                "top_logprobs",
+                request_leaves=("scoring.top_logprobs",),
+                response_channels=("top_logprobs",),
+                _config_validator=_validate_top_logprobs_config,
+            )
+        ),
+        "reasoning": Supported(
+            DialectCapabilityBinding(
+                "reasoning",
+                request_leaves=(
+                    "reasoning.effort",
+                    "reasoning.budget_tokens",
+                    "reasoning.summary",
+                ),
+                response_channels=("reasoning",),
+                _config_validator=_validate_reasoning_config,
+            )
+        ),
+        "function_tools": Supported(
+            DialectCapabilityBinding(
+                "function_tools",
+                request_leaves=("tools.functions", "tools.choice"),
+                response_channels=("tool_calls",),
+            )
+        ),
+        "hosted_tools": Supported(
+            DialectCapabilityBinding(
+                "hosted_tools",
+                request_leaves=("tools.hosted",),
+                response_channels=("server_tool_uses",),
+                _config_validator=_validate_hosted_tools_config,
+            )
+        ),
+        "structured_output": Supported(
+            DialectCapabilityBinding(
+                "structured_output",
+                request_leaves=(
+                    "structured_output.format",
+                    "structured_output.schema",
+                    "structured_output.name",
+                    "structured_output.strict",
+                ),
+                response_channels=("structured_output",),
+            )
+        ),
+        "stateful_session": Unsupported(
+            "Gemini responseId is not a request continuation handle"
+        ),
+        "opaque_continuation": Supported(
+            DialectCapabilityBinding(
+                "opaque_continuation",
+                request_leaves=("session.opaque_continuation",),
+                response_channels=("reasoning",),
+            )
+        ),
+        "multimodal_input": Supported(
+            DialectCapabilityBinding(
+                "multimodal_input",
+                request_leaves=(
+                    "input.modality.image",
+                    "input.modality.image.media_type",
+                ),
+                _config_validator=_validate_multimodal_config,
+            )
+        ),
+        "prefill": Unsupported("Gemini has no independent assistant-prefill field"),
+        "fim": Unsupported("Gemini generateContent has no completion suffix field"),
+    }
+    if set(decisions) != set(CAPABILITY_KEYS):
+        raise AssertionError("Google GenAI capability row is incomplete")
+    return MappingProxyType(decisions)
+
+
+CAPABILITY_DECISIONS = _decisions()
+
+OUTPUT_CONTRACT = OutputContract(
+    {
+        "reasoning": OutputRule(Guarantee.PRESENT_OR_ERROR, validate_reasoning),
+        "tool_calls": OutputRule(Guarantee.BEST_EFFORT, validate_tool_calls),
+        "server_tool_uses": OutputRule(
+            Guarantee.BEST_EFFORT,
+            _tuple_validator(ServerToolUse, "server_tool_uses"),
+        ),
+        "structured_output": OutputRule(
+            Guarantee.PRESENT_OR_ERROR, validate_structured_output
+        ),
+        "logprobs": OutputRule(
+            Guarantee.PRESENT_OR_ERROR,
+            _tuple_validator(TokenLogprob, "logprobs"),
+        ),
+        "top_logprobs": OutputRule(Guarantee.PRESENT_OR_ERROR, validate_top_logprobs),
+        "input_scoring": OutputRule(Guarantee.NEVER),
+        "citations": OutputRule(
+            Guarantee.BEST_EFFORT, _tuple_validator(Citation, "citations")
+        ),
+        "grounding": OutputRule(Guarantee.BEST_EFFORT),
+        "session_id": OutputRule(Guarantee.NEVER),
+        "usage": OutputRule(Guarantee.BEST_EFFORT),
+    },
+    empty_outcome_finish_reasons=_CHANNEL_OPTIONAL_FINISH_REASONS,
+)
+
+type _SyntheticCallKey = tuple[int, int, str]
+
+
+@dataclass(frozen=True)
+class _GoogleContext:
+    request: Request
+    synthetic_call_ids: Mapping[_SyntheticCallKey, str]
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "synthetic_call_ids",
+            MappingProxyType(dict(self.synthetic_call_ids)),
+        )
+
+
+@dataclass(frozen=True)
+class _GoogleExecutionContext:
+    request: Request
+    request_params: Mapping[str, JSONValue]
+    system_instruction: Mapping[str, JSONValue] | None
+    input_contents: tuple[Mapping[str, JSONValue], ...]
+    synthetic_call_ids: Mapping[_SyntheticCallKey, str]
+    historical_function_call_ids: frozenset[str]
+    historical_server_call_ids: frozenset[str]
+
+
+@dataclass(frozen=True)
+class _LegacyPlan:
+    dialect_id: str = "google_genai"
+    available_capabilities: frozenset[str] = frozenset(
+        key
+        for key, decision in CAPABILITY_DECISIONS.items()
+        if isinstance(decision, Supported)
+    )
+    capability_minimums: Mapping[str, Mapping[str, JSONValue]] = field(
+        default_factory=dict
+    )
+    required_output_channels: frozenset[str] = frozenset()
+
+
+@dataclass(frozen=True)
+class _OperationVerifier:
+    model_name: str
+    api_version: str
+    stream: bool
+
+    def verify_prepared(self, prepared: PreparedRequest) -> str | None:
+        """Derive the expected route independently from request lowering."""
+
+        method = "streamGenerateContent" if self.stream else "generateContent"
+        expected = (
+            f"{self.api_version}/models/{quote(self.model_name, safe='')}:{method}"
+        )
+        if self.stream:
+            expected = f"{expected}?alt=sse"
+        if prepared.operation != expected:
+            return f"operation {prepared.operation!r} does not match {expected!r}"
+        return None
+
+    def verify_http(self, request: httpx.Request, endpoint_root: httpx.URL) -> None:
+        """Check the final HTTP target against the bound model and version."""
+
+        method = "streamGenerateContent" if self.stream else "generateContent"
+        expected = endpoint_root.join(
+            f"{self.api_version}/models/{quote(self.model_name, safe='')}:{method}"
+        )
+        if self.stream:
+            expected = expected.copy_with(query=b"alt=sse")
+        if request.method != "POST" or request.url != expected:
+            raise DialectError(
+                "final Google request URL or method does not match the bound "
+                f"{self.api_version} operation"
+            )
+
+
+@dataclass(frozen=True)
+class _InputVerifier:
+    expected_system: Mapping[str, JSONValue] | None
+    expected_contents: tuple[JSONValue, ...]
+
+    @classmethod
+    def from_request(
+        cls, request_input: ChatInput, opaque: str | None
+    ) -> "_InputVerifier":
+        system, contents = _verification_input_to_wire(request_input, opaque)
+        return cls(system, tuple(contents))
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        if body.get("contents") != list(self.expected_contents):
+            return "contents no longer match the provider-neutral input"
+        if body.get("systemInstruction") != self.expected_system:
+            return "systemInstruction no longer matches system/developer messages"
+        return None
+
+
+def _get(raw: object, name: str, default: object = None) -> object:
+    if isinstance(raw, Mapping):
+        return cast(Mapping[object, object], raw).get(name, default)
+    return getattr(raw, name, default)
+
+
+def _sequence(raw: object, path: str) -> Sequence[object]:
+    if not isinstance(raw, Sequence) or isinstance(raw, str | bytes):
+        raise OutputContractError(f"{path} must be a sequence")
+    return cast(Sequence[object], raw)
+
+
+def _required_string(raw: object, path: str) -> str:
+    if not isinstance(raw, str) or not raw:
+        raise OutputContractError(f"{path} must be a non-empty string")
+    return raw
+
+
+def _string(raw: object, path: str) -> str:
+    if not isinstance(raw, str):
+        raise OutputContractError(f"{path} must be a string")
+    return raw
+
+
+def _optional_string(raw: object, path: str) -> str | None:
+    if raw is None:
+        return None
+    if not isinstance(raw, str):
+        raise OutputContractError(f"{path} must be a string or None")
+    return raw
+
+
+def _finite_number(raw: object, path: str) -> float:
+    if isinstance(raw, bool) or not isinstance(raw, int | float):
+        raise OutputContractError(f"{path} must be numeric")
+    value = float(raw)
+    if not math.isfinite(value):
+        raise OutputContractError(f"{path} must be finite")
+    return value
+
+
+def _nonnegative_int(raw: object, path: str, *, default: int = 0) -> int:
+    if raw is None:
+        return default
+    if isinstance(raw, bool) or not isinstance(raw, int) or raw < 0:
+        raise OutputContractError(f"{path} must be a non-negative integer")
+    return raw
+
+
+def _optional_nonnegative_int(raw: object, path: str) -> int | None:
+    if raw is None:
+        return None
+    return _nonnegative_int(raw, path)
+
+
+def _function_declaration_source(raw: Mapping[str, JSONValue]) -> dict[str, JSONValue]:
+    data = dict(raw)
+    if data.get("type") == "function":
+        nested = data.get("function")
+        if nested is not None:
+            if set(data) != {"type", "function"} or not isinstance(nested, Mapping):
+                raise DialectError("invalid OpenAI-shaped function declaration")
+            data = dict(nested)
+        else:
+            data.pop("type")
+    allowed = {"name", "description", "parameters"}
+    unknown = set(data) - allowed
+    if unknown:
+        raise DialectError(
+            "unsupported Google function declaration field(s): "
+            + ", ".join(sorted(unknown))
+        )
+    name = data.get("name")
+    if not isinstance(name, str) or not name:
+        raise DialectError("Google function declaration requires a name")
+    if _FUNCTION_NAME_PATTERN.fullmatch(name) is None:
+        raise DialectError(
+            "Google function name must be at most 128 characters and contain "
+            "only letters, digits, underscores, colons, dots, or dashes"
+        )
+    description = data.get("description")
+    if description is None:
+        raise DialectError(
+            "Google function declaration requires a non-empty description"
+        )
+    if not isinstance(description, str):
+        raise DialectError("Google function description must be a string")
+    if not description.strip():
+        raise DialectError("Google function description must not be empty")
+    result: dict[str, JSONValue] = {"name": name, "description": description}
+    if "parameters" in data:
+        parameters = data["parameters"]
+        if not isinstance(parameters, Mapping):
+            raise DialectError("Google function parameters must be an object")
+        validate_function_parameters(parameters)
+        result["parameters"] = dict(parameters)
+    return result
+
+
+def _function_declaration(
+    raw: Mapping[str, JSONValue], contract: GoogleWireContract
+) -> dict[str, JSONValue]:
+    result = _function_declaration_source(raw)
+    if "parameters" in result:
+        parameters = result.pop("parameters")
+        if contract.function_schema_field == "parameters":
+            parameters = lower_function_schema(parameters)
+        result[contract.function_schema_field] = parameters
+    return result
+
+
+def _tool_choice(
+    raw: JSONValue, *, include_server_side_invocations: bool = False
+) -> dict[str, JSONValue]:
+    if isinstance(raw, str):
+        modes = {
+            "auto": "VALIDATED" if include_server_side_invocations else "AUTO",
+            "none": "NONE",
+            "required": "ANY",
+        }
+        try:
+            return {"functionCallingConfig": {"mode": modes[raw]}}
+        except KeyError as exc:
+            raise DialectError(f"unsupported Google tool choice {raw!r}") from exc
+    if not isinstance(raw, Mapping):
+        raise DialectError("Google tool choice must be a string or mapping")
+    data = dict(raw)
+    nested = data.get("function")
+    if set(data) == {"type", "function"} and isinstance(nested, Mapping):
+        name = nested.get("name")
+    elif set(data) == {"type", "name"} and data.get("type") == "function":
+        name = data.get("name")
+    else:
+        raise DialectError("invalid Google function-specific tool choice")
+    if not isinstance(name, str) or not name:
+        raise DialectError("Google function-specific tool choice requires a name")
+    return {
+        "functionCallingConfig": {
+            "mode": "ANY",
+            "allowedFunctionNames": [name],
+        }
+    }
+
+
+def _thinking_level_error(
+    model_name: str,
+    constraints: _GoogleModelRequestConstraints,
+    effort: str,
+) -> str | None:
+    levels = constraints.thinking_levels
+    if levels is None:
+        return None
+    if not levels:
+        return (
+            f"{model_name} does not support thinkingLevel; use reasoning.budget_tokens"
+        )
+    normalized = effort.lower()
+    if normalized in levels:
+        return None
+    return (
+        f"{model_name} supports reasoning.effort values "
+        f"{', '.join(sorted(levels))}; got {effort!r}"
+    )
+
+
+def _thinking_budget_error(
+    model_name: str,
+    constraints: _GoogleModelRequestConstraints,
+    budget_tokens: int,
+) -> str | None:
+    budget_range = constraints.positive_thinking_budget_range
+    if budget_range is None:
+        return None
+    minimum, maximum = budget_range
+    if minimum <= budget_tokens <= maximum:
+        return None
+    return (
+        f"{model_name} reasoning.budget_tokens must be between {minimum} and {maximum}"
+    )
+
+
+def _tool_combination_error(
+    model_name: str,
+    constraints: _GoogleModelRequestConstraints,
+    *,
+    has_functions: bool,
+    has_hosted: bool,
+) -> str | None:
+    # Google documents mixed built-in/custom tools for Gemini 3 only. Do not
+    # infer a model family from an unknown provider alias, or conflate this
+    # combination restriction with standalone hosted-tool support.
+    # https://ai.google.dev/gemini-api/docs/generate-content/tool-combination
+    if has_functions and has_hosted and constraints.mixed_tools_supported is False:
+        return (
+            f"{model_name} does not support combining hosted tools with custom "
+            "functions; Google tool combinations require Gemini 3"
+        )
+    return None
+
+
+def _rfc3339_timestamp_ns(value: str) -> int | None:
+    """Return a comparable UTC nanosecond value for a Google timestamp."""
+
+    match = _RFC3339_TIMESTAMP_PATTERN.fullmatch(value)
+    if match is None:
+        return None
+    offset = "+00:00" if match["offset"] == "Z" else match["offset"]
+    try:
+        parsed = datetime.fromisoformat(
+            f"{match['date']}T{match['time']}{offset}"
+        ).astimezone(UTC)
+    except ValueError:
+        return None
+    epoch = datetime(1970, 1, 1, tzinfo=UTC)
+    delta = parsed - epoch
+    whole_seconds = delta.days * 86400 + delta.seconds
+    fraction = (match["fraction"] or "").ljust(9, "0")
+    return whole_seconds * 1_000_000_000 + int(fraction or "0")
+
+
+def _hosted_tool_config_error(kind: str, config: object) -> str | None:
+    if not isinstance(config, Mapping):
+        return f"Google hosted tool {kind!r} config must be an object"
+    data = cast(Mapping[object, object], config)
+    if kind == "url_context":
+        if data:
+            return "Google url_context config must be an empty object"
+        return None
+    if kind != "google_search":
+        return f"unsupported Google hosted tool {kind!r}"
+
+    unknown = set(data) - {"timeRangeFilter", "searchTypes"}
+    if unknown:
+        return "Google google_search config has unsupported field(s): " + ", ".join(
+            sorted(str(key) for key in unknown)
+        )
+    time_range = data.get("timeRangeFilter")
+    if time_range is not None:
+        if not isinstance(time_range, Mapping):
+            return "Google google_search.timeRangeFilter must be an object"
+        interval = cast(Mapping[object, object], time_range)
+        interval_unknown = set(interval) - {"startTime", "endTime"}
+        if interval_unknown:
+            return (
+                "Google google_search.timeRangeFilter has unsupported field(s): "
+                + ", ".join(sorted(str(key) for key in interval_unknown))
+            )
+        has_start = "startTime" in interval
+        has_end = "endTime" in interval
+        if has_start != has_end:
+            return (
+                "Google google_search.timeRangeFilter requires startTime and "
+                "endTime together"
+            )
+        parsed_times: dict[str, int] = {}
+        for key in ("startTime", "endTime"):
+            if key in interval and (
+                not isinstance(interval[key], str) or not interval[key]
+            ):
+                return (
+                    f"Google google_search.timeRangeFilter.{key} must be a "
+                    "non-empty timestamp string"
+                )
+            if key in interval:
+                value = cast(str, interval[key])
+                parsed = _rfc3339_timestamp_ns(value)
+                if parsed is None:
+                    return (
+                        f"Google google_search.timeRangeFilter.{key} must be an "
+                        "RFC3339 timestamp with an explicit UTC offset"
+                    )
+                parsed_times[key] = parsed
+        if (
+            "startTime" in parsed_times
+            and "endTime" in parsed_times
+            and parsed_times["startTime"] > parsed_times["endTime"]
+        ):
+            return (
+                "Google google_search.timeRangeFilter.startTime must not be after "
+                "endTime"
+            )
+
+    search_types = data.get("searchTypes")
+    if search_types is not None:
+        if not isinstance(search_types, Mapping):
+            return "Google google_search.searchTypes must be an object"
+        search_mapping = cast(Mapping[object, object], search_types)
+        search_unknown = set(search_mapping) - {"webSearch", "imageSearch"}
+        if search_unknown:
+            return (
+                "Google google_search.searchTypes has unsupported field(s): "
+                + ", ".join(sorted(str(key) for key in search_unknown))
+            )
+        for key in ("webSearch", "imageSearch"):
+            if key in search_mapping and (
+                not isinstance(search_mapping[key], Mapping)
+                or bool(search_mapping[key])
+            ):
+                return f"Google google_search.searchTypes.{key} must be an empty object"
+    return None
+
+
+def _validate_final_hosted_tools(body: Mapping[str, JSONValue]) -> None:
+    raw_tools = body.get("tools")
+    if not isinstance(raw_tools, Sequence) or isinstance(raw_tools, str | bytes):
+        return
+    for index, raw_tool in enumerate(raw_tools):
+        if not isinstance(raw_tool, Mapping):
+            continue
+        for field_name, kind in (
+            ("googleSearch", "google_search"),
+            ("urlContext", "url_context"),
+        ):
+            if field_name not in raw_tool:
+                continue
+            error = _hosted_tool_config_error(kind, raw_tool[field_name])
+            if error is not None:
+                raise DialectError(f"final Google tools[{index}]: {error}")
+
+
+def _validate_final_function_call_ids(
+    body: Mapping[str, JSONValue],
+    model_name: str,
+) -> None:
+    if not _requires_exact_function_call_ids(model_name):
+        return
+    contents = body.get("contents")
+    if not isinstance(contents, Sequence) or isinstance(contents, str | bytes):
+        return
+    for content_index, content in enumerate(contents):
+        if not isinstance(content, Mapping):
+            continue
+        parts = content.get("parts")
+        if not isinstance(parts, Sequence) or isinstance(parts, str | bytes):
+            continue
+        for part_index, part in enumerate(parts):
+            if not isinstance(part, Mapping):
+                continue
+            for field_name in ("functionCall", "functionResponse"):
+                if field_name not in part:
+                    continue
+                raw_call = part[field_name]
+                if not isinstance(raw_call, Mapping):
+                    raise DialectError(
+                        f"final Google contents[{content_index}].parts[{part_index}]."
+                        f"{field_name} must be an object"
+                    )
+                call_id = raw_call.get("id")
+                if not isinstance(call_id, str) or not call_id:
+                    raise DialectError(
+                        f"{model_name} requires every {field_name} to contain the "
+                        "exact non-empty provider call id"
+                    )
+
+
+def _validate_final_function_call_signatures(
+    body: Mapping[str, JSONValue],
+    model_name: str,
+) -> None:
+    """Validate Gemini 3 signatures only within Google's current turn."""
+
+    if _GEMINI_3_MODEL_PATTERN.match(model_name) is None:
+        return
+    contents = body.get("contents")
+    if not isinstance(contents, Sequence) or isinstance(contents, str | bytes):
+        return
+
+    current_turn_start = 0
+    for content_index, raw_content in enumerate(contents):
+        if not isinstance(raw_content, Mapping):
+            continue
+        content = cast(Mapping[str, object], raw_content)
+        if content.get("role") != "user":
+            continue
+        parts = content.get("parts")
+        if not isinstance(parts, Sequence) or isinstance(parts, str | bytes):
+            continue
+        if any(
+            isinstance(part, Mapping) and bool(_STANDARD_USER_PART_FIELDS & part.keys())
+            for part in parts
+        ):
+            current_turn_start = content_index
+
+    for content_index in range(current_turn_start, len(contents)):
+        raw_content = contents[content_index]
+        if not isinstance(raw_content, Mapping):
+            continue
+        content = cast(Mapping[str, object], raw_content)
+        if content.get("role") != "model":
+            continue
+        parts = content.get("parts")
+        if not isinstance(parts, Sequence) or isinstance(parts, str | bytes):
+            continue
+        for part_index, part in enumerate(parts):
+            if not isinstance(part, Mapping) or "functionCall" not in part:
+                continue
+            signature = part.get("thoughtSignature")
+            if not isinstance(signature, str) or not signature:
+                raise DialectError(
+                    f"{model_name} current-turn functionCall at "
+                    f"contents[{content_index}].parts[{part_index}] must preserve "
+                    "the exact non-empty thoughtSignature; replay the returned "
+                    "opaque continuation instead of reconstructing Gemini 3 "
+                    "tool history"
+                )
+            break
+
+
+def _server_tool_signature_error(part: Mapping[str, object], path: str) -> str | None:
+    for field_name in ("toolCall", "toolResponse"):
+        if field_name not in part:
+            continue
+        signature = part.get("thoughtSignature")
+        if not isinstance(signature, str) or not signature:
+            return (
+                f"{path}.{field_name} must preserve a non-empty thoughtSignature "
+                "for Gemini 3 tool-context circulation"
+            )
+    return None
+
+
+def _validate_server_tool_history_signatures(
+    body: Mapping[str, JSONValue], model_name: str
+) -> None:
+    """Check circulated server state, including before the current user turn.
+
+    A subsequent request need not enable hosted tools again. The server-tool
+    parts themselves identify circulated history, so omitting the current
+    invocation flag must not bypass this check. Ordinary functionCall parts
+    retain their separate first-call/current-turn signature contract.
+    """
+
+    if _GEMINI_3_MODEL_PATTERN.match(model_name) is None:
+        return
+    contents = body.get("contents")
+    if not isinstance(contents, Sequence) or isinstance(contents, str | bytes):
+        return
+    for content_index, content in enumerate(contents):
+        if not isinstance(content, Mapping):
+            continue
+        parts = content.get("parts")
+        if not isinstance(parts, Sequence) or isinstance(parts, str | bytes):
+            continue
+        for part_index, part in enumerate(parts):
+            if not isinstance(part, Mapping):
+                continue
+            error = _server_tool_signature_error(
+                part, f"Google contents[{content_index}].parts[{part_index}]"
+            )
+            if error is not None:
+                raise DialectError(error)
+
+
+def _validate_final_request_constraints(
+    body: Mapping[str, JSONValue], model_name: str
+) -> None:
+    constraints = _model_request_constraints(model_name)
+    _validate_final_function_call_ids(body, model_name)
+    _validate_final_function_call_signatures(body, model_name)
+    _validate_server_tool_history_signatures(body, model_name)
+    generation = body.get("generationConfig")
+    if isinstance(generation, Mapping):
+        generation_mapping = cast(Mapping[str, object], generation)
+        if constraints.omit_sampling_controls:
+            present = sorted(_GEMINI_3_SAMPLING_WIRE_KEYS & generation_mapping.keys())
+            if present:
+                raise DialectError(
+                    f"{model_name} final request contains sampling controls Google "
+                    f"says to omit: {', '.join(present)}"
+                )
+        candidate_count = generation_mapping.get("candidateCount")
+        if (
+            constraints.maximum_candidates is not None
+            and isinstance(candidate_count, int)
+            and not isinstance(candidate_count, bool)
+            and candidate_count > constraints.maximum_candidates
+        ):
+            raise DialectError(
+                "Gemini 3 models do not support candidateCount greater than 1"
+            )
+        thinking = generation_mapping.get("thinkingConfig")
+        if isinstance(thinking, Mapping):
+            thinking_mapping = cast(Mapping[str, object], thinking)
+            level = thinking_mapping.get("thinkingLevel")
+            if isinstance(level, str) and (
+                error := _thinking_level_error(model_name, constraints, level.lower())
+            ):
+                raise DialectError(error)
+            budget = thinking_mapping.get("thinkingBudget")
+            if (
+                isinstance(budget, int)
+                and not isinstance(budget, bool)
+                and (error := _thinking_budget_error(model_name, constraints, budget))
+            ):
+                raise DialectError(error)
+
+    _validate_final_hosted_tools(body)
+    tools = body.get("tools")
+    if isinstance(tools, Sequence) and not isinstance(tools, str | bytes):
+        error = _tool_combination_error(
+            model_name,
+            constraints,
+            has_functions=any(
+                isinstance(tool, Mapping) and bool(_get(tool, "functionDeclarations"))
+                for tool in tools
+            ),
+            has_hosted=any(
+                isinstance(tool, Mapping)
+                and ("googleSearch" in tool or "urlContext" in tool)
+                for tool in tools
+            ),
+        )
+        if error is not None:
+            raise DialectError(error)
+
+    tool_config = body.get("toolConfig")
+    if not isinstance(tool_config, Mapping):
+        return
+    tool_config_mapping = cast(Mapping[str, object], tool_config)
+    function_config = tool_config_mapping.get("functionCallingConfig")
+    function_mode = (
+        cast(Mapping[str, object], function_config).get("mode")
+        if isinstance(function_config, Mapping)
+        else None
+    )
+    if (
+        tool_config_mapping.get("includeServerSideToolInvocations") is True
+        and function_mode == "AUTO"
+    ):
+        raise DialectError(
+            "Google server-side tool invocation circulation does not support "
+            "function calling mode AUTO; use VALIDATED"
+        )
+
+
+def _allowed_function_call_names(req: Request) -> frozenset[str]:
+    declared = frozenset(
+        cast(str, _function_declaration_source(item)["name"])
+        for item in req.tools.functions
+    )
+    choice = req.tools.choice
+    if choice is None:
+        return declared
+    if isinstance(choice, str):
+        return frozenset() if choice == "none" else declared
+    normalized = _tool_choice(choice)
+    allowed = _get(
+        _get(normalized, "functionCallingConfig"),
+        "allowedFunctionNames",
+        [],
+    )
+    return frozenset(
+        _required_string(name, "tool choice allowed function")
+        for name in _sequence(allowed, "tool choice allowed functions")
+    )
+
+
+def _allowed_server_tool_types(req: Request) -> frozenset[str]:
+    allowed: set[str] = set()
+    for tool in req.tools.hosted:
+        if tool.kind == "url_context":
+            allowed.add("URL_CONTEXT")
+            continue
+        if tool.kind != "google_search":
+            continue
+        search_types = tool.config.get("searchTypes")
+        if search_types is None:
+            allowed.add("GOOGLE_SEARCH_WEB")
+            continue
+        if not isinstance(search_types, Mapping):
+            continue
+        search_types_mapping = cast(Mapping[str, object], search_types)
+        if search_types_mapping.get("webSearch") is not None:
+            allowed.add("GOOGLE_SEARCH_WEB")
+        if search_types_mapping.get("imageSearch") is not None:
+            allowed.add("GOOGLE_SEARCH_IMAGE")
+    return frozenset(allowed)
+
+
+def _hosted_tool(spec: object) -> dict[str, JSONValue]:
+    kind = getattr(spec, "kind", None)
+    config = getattr(spec, "config", None)
+    if not isinstance(kind, str):
+        raise DialectError(f"unsupported Google hosted tool {kind!r}")
+    if error := _hosted_tool_config_error(kind, config):
+        raise DialectError(error)
+    assert isinstance(config, Mapping)
+    key = "googleSearch" if kind == "google_search" else "urlContext"
+    return {key: dict(config)}
+
+
+def _image_to_part(part: ImagePart) -> dict[str, JSONValue]:
+    if part.detail is not None:
+        raise DialectError("Google image parts have no per-image detail field")
+    if part.media_type is not None and part.media_type not in _IMAGE_MEDIA_TYPES:
+        raise DialectError(f"unsupported Google image media type {part.media_type!r}")
+    if part.url is not None:
+        if not part.url:
+            raise DialectError("Google image URLs must not be empty")
+        data: dict[str, JSONValue] = {"fileUri": part.url}
+        if part.media_type is not None:
+            data["mimeType"] = part.media_type
+        return {"fileData": data}
+    if not part.data or not part.media_type:
+        raise DialectError(
+            "Google inline images require data and an explicit MIME type"
+        )
+    return {"inlineData": {"data": part.data, "mimeType": part.media_type}}
+
+
+def _tool_result_payload(part: ToolResultPart) -> dict[str, JSONValue]:
+    value = copy_json_value(part.result, "function response")
+    if part.is_error:
+        return {"error": value}
+    if isinstance(value, dict):
+        return dict(value)
+    return {"result": value}
+
+
+def _content_parts(
+    message: ChatMessage,
+    call_names: dict[str, str],
+    answered_calls: set[str],
+    call_wire_ids: dict[str, str | None],
+    synthetic_call_ids: dict[_SyntheticCallKey, str],
+    content_index: int | None,
+) -> list[JSONValue]:
+    parts: list[JSONValue] = []
+    for part in message.content:
+        if isinstance(part, TextPart):
+            if message.role == "tool":
+                raise DialectError("Google tool messages may contain only tool results")
+            parts.append({"text": part.text})
+        elif isinstance(part, ImagePart):
+            if message.role == "tool":
+                raise DialectError("Google tool messages may contain only tool results")
+            parts.append(_image_to_part(part))
+        elif isinstance(part, ToolCallPart):
+            if message.role != "assistant":
+                raise DialectError(
+                    "Google historical function calls require assistant role"
+                )
+            if not part.call_id or not part.name:
+                raise DialectError(
+                    "Google historical function calls require id and name"
+                )
+            if part.call_id in call_names:
+                raise DialectError(
+                    f"duplicate Google function call id {part.call_id!r}"
+                )
+            call_names[part.call_id] = part.name
+            call_wire_ids[part.call_id] = part.call_id
+            parts.append(
+                {
+                    "functionCall": {
+                        "id": part.call_id,
+                        "name": part.name,
+                        "args": copy_json_value(part.arguments, "function arguments"),
+                    }
+                }
+            )
+        elif isinstance(part, ToolResultPart):
+            if message.role != "tool":
+                raise DialectError("Google function results require tool role")
+            try:
+                name = call_names[part.call_id]
+            except KeyError as exc:
+                raise DialectError(
+                    f"Google function result {part.call_id!r} has no prior call"
+                ) from exc
+            if part.call_id in answered_calls:
+                raise DialectError(
+                    f"duplicate Google function result for {part.call_id!r}"
+                )
+            answered_calls.add(part.call_id)
+            wire_id = call_wire_ids[part.call_id]
+            response: dict[str, JSONValue] = {
+                "name": name,
+                "response": _tool_result_payload(part),
+            }
+            if wire_id is not None:
+                response["id"] = wire_id
+            parts.append({"functionResponse": response})
+            if wire_id is None:
+                if content_index is None:
+                    raise AssertionError(
+                        "Google function responses require a conversation index"
+                    )
+                synthetic_call_ids[
+                    (content_index, len(parts) - 1, "functionResponse")
+                ] = part.call_id
+        else:
+            raise DialectError(f"unsupported Google content part {type(part).__name__}")
+    if not parts:
+        raise DialectError("Google contents must not contain an empty message")
+    return parts
+
+
+_OPAQUE_PART_FIELDS = frozenset(
+    {
+        "text",
+        "inlineData",
+        "fileData",
+        "functionCall",
+        "functionResponse",
+        "toolCall",
+        "toolResponse",
+    }
+)
+_PART_AUXILIARY_FIELDS = frozenset(
+    {"partMetadata", "mediaResolution", "mediaProcessing", "videoMetadata"}
+)
+_SYNTHETIC_CALL_FIELDS = frozenset(
+    {"functionCall", "functionResponse", "toolCall", "toolResponse"}
+)
+
+
+def _part_auxiliary_error(part: Mapping[str, object], path: str) -> str | None:
+    for field_name in ("partMetadata", "mediaResolution", "videoMetadata"):
+        value = part.get(field_name)
+        if value is not None and not isinstance(value, Mapping):
+            return f"{path}.{field_name} must be an object"
+    media_processing = part.get("mediaProcessing")
+    if media_processing is not None and (
+        not isinstance(media_processing, str) or not media_processing
+    ):
+        return f"{path}.mediaProcessing must be a non-empty string"
+    return None
+
+
+def _validate_opaque_contents(raw: object) -> list[dict[str, JSONValue]]:
+    if not isinstance(raw, list) or not raw:
+        raise DialectError("Google opaque continuation has no contents")
+    copied = copy_json_value(raw, "Google opaque continuation contents")
+    if not isinstance(copied, list):
+        raise AssertionError("copied Google contents must remain a list")
+    result: list[dict[str, JSONValue]] = []
+    for content_index, content in enumerate(copied):
+        if not isinstance(content, dict) or set(content) != {"role", "parts"}:
+            raise DialectError(
+                f"Google opaque content {content_index} has invalid shape"
+            )
+        if content["role"] not in {"user", "model"}:
+            raise DialectError(
+                f"Google opaque content {content_index} has invalid role"
+            )
+        parts = content["parts"]
+        if not isinstance(parts, list) or not parts:
+            raise DialectError(f"Google opaque content {content_index} has no parts")
+        for part_index, part in enumerate(parts):
+            if not isinstance(part, dict):
+                raise DialectError(
+                    f"Google opaque part {content_index}.{part_index} is not an object"
+                )
+            unknown = set(part) - (
+                _OPAQUE_PART_FIELDS
+                | _PART_AUXILIARY_FIELDS
+                | {"thought", "thoughtSignature"}
+            )
+            if unknown:
+                raise DialectError(
+                    "Google opaque part has unsupported field(s): "
+                    + ", ".join(sorted(unknown))
+                )
+            data_fields = set(part) & _OPAQUE_PART_FIELDS
+            if len(data_fields) != 1:
+                raise DialectError("Google opaque part must contain one data field")
+            if "text" in part and not isinstance(part["text"], str):
+                raise DialectError("Google opaque text part must contain a string")
+            for key in data_fields - {"text"}:
+                if not isinstance(part[key], dict):
+                    raise DialectError(f"Google opaque {key} must be an object")
+            if error := _part_auxiliary_error(
+                part, f"Google opaque part {content_index}.{part_index}"
+            ):
+                raise DialectError(error)
+            thought = part.get("thought")
+            if thought is not None and not isinstance(thought, bool):
+                raise DialectError("Google opaque thought marker must be boolean")
+            signature = part.get("thoughtSignature")
+            if signature is not None and (
+                not isinstance(signature, str) or not signature
+            ):
+                raise DialectError(
+                    "Google opaque thoughtSignature must be a non-empty string"
+                )
+        result.append(content)
+    return result
+
+
+def _has_thought_signature(contents: Sequence[Mapping[str, JSONValue]]) -> bool:
+    for content in contents:
+        parts = content.get("parts")
+        if not isinstance(parts, list):
+            continue
+        for raw_part in parts:
+            if not isinstance(raw_part, Mapping):
+                continue
+            part = cast(Mapping[str, object], raw_part)
+            signature = part.get("thoughtSignature")
+            if isinstance(signature, str) and signature:
+                return True
+    return False
+
+
+def _validate_opaque_system(
+    raw: object,
+) -> dict[str, JSONValue] | None:
+    if raw is None:
+        return None
+    copied = copy_json_value(raw, "Google opaque systemInstruction")
+    if not isinstance(copied, dict) or set(copied) != {"parts"}:
+        raise DialectError("Google opaque systemInstruction has invalid shape")
+    parts = copied["parts"]
+    if not isinstance(parts, list) or not parts:
+        raise DialectError("Google opaque systemInstruction has no parts")
+    if any(
+        not isinstance(part, dict)
+        or set(part) != {"text"}
+        or not isinstance(part["text"], str)
+        for part in parts
+    ):
+        raise DialectError("Google opaque systemInstruction must be text-only")
+    return cast(dict[str, JSONValue], copied)
+
+
+def _validate_synthetic_call_ids(
+    raw: object,
+    contents: Sequence[Mapping[str, JSONValue]],
+) -> dict[_SyntheticCallKey, str]:
+    if raw is None:
+        return {}
+    if not isinstance(raw, list):
+        raise DialectError("Google opaque syntheticCallIds must be a list")
+    result: dict[_SyntheticCallKey, str] = {}
+    for index, raw_item in enumerate(raw):
+        if not isinstance(raw_item, Mapping) or set(raw_item) != {
+            "contentIndex",
+            "partIndex",
+            "field",
+            "id",
+        }:
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] has invalid shape"
+            )
+        item = cast(Mapping[str, object], raw_item)
+        content_index = item["contentIndex"]
+        part_index = item["partIndex"]
+        field_name = item["field"]
+        call_id = item["id"]
+        if (
+            isinstance(content_index, bool)
+            or not isinstance(content_index, int)
+            or content_index < 0
+            or isinstance(part_index, bool)
+            or not isinstance(part_index, int)
+            or part_index < 0
+        ):
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] indexes must be "
+                "non-negative integers"
+            )
+        if not isinstance(field_name, str) or field_name not in _SYNTHETIC_CALL_FIELDS:
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] has invalid field"
+            )
+        if not isinstance(call_id, str) or not call_id:
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}].id must be non-empty"
+            )
+        try:
+            parts = contents[content_index]["parts"]
+            if not isinstance(parts, list):
+                raise TypeError
+            part = parts[part_index]
+        except (IndexError, KeyError, TypeError) as exc:
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] points outside contents"
+            ) from exc
+        if not isinstance(part, Mapping) or field_name not in part:
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] points to the wrong part"
+            )
+        part_mapping = cast(Mapping[str, object], part)
+        raw_call = part_mapping[field_name]
+        if not isinstance(raw_call, Mapping):
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] requires a call without id"
+            )
+        call_mapping = cast(Mapping[str, object], raw_call)
+        raw_id = call_mapping.get("id")
+        if raw_id is not None and raw_id != "":
+            raise DialectError(
+                f"Google opaque syntheticCallIds[{index}] requires a call without id"
+            )
+        key = (content_index, part_index, field_name)
+        if key in result:
+            raise DialectError("Google opaque syntheticCallIds contains a duplicate")
+        result[key] = call_id
+    return result
+
+
+def _decode_opaque(
+    value: str,
+) -> tuple[
+    dict[str, JSONValue] | None,
+    list[dict[str, JSONValue]],
+    dict[_SyntheticCallKey, str],
+]:
+    try:
+        raw = json.loads(
+            value,
+            object_pairs_hook=_reject_duplicate_keys,
+            parse_constant=_reject_json_constant,
+        )
+    except (json.JSONDecodeError, TypeError, ValueError) as exc:
+        raise DialectError("invalid Google opaque continuation JSON") from exc
+    if (
+        not isinstance(raw, dict)
+        or not {"version", "contents"}.issubset(raw)
+        or set(raw) - {"version", "contents", "systemInstruction", "syntheticCallIds"}
+    ):
+        raise DialectError("invalid Google opaque continuation envelope")
+    if raw.get("version") != _OPAQUE_VERSION:
+        raise DialectError("unsupported Google opaque continuation version")
+    system = _validate_opaque_system(raw.get("systemInstruction"))
+    contents = _validate_opaque_contents(raw.get("contents"))
+    synthetic_call_ids = _validate_synthetic_call_ids(
+        raw.get("syntheticCallIds"), contents
+    )
+    if not _has_thought_signature(contents) and not synthetic_call_ids:
+        raise DialectError(
+            "Google opaque continuation has no thought signature or synthetic "
+            "call correlation"
+        )
+    return system, contents, synthetic_call_ids
+
+
+def _local_call_id(
+    raw_call: Mapping[str, object],
+    key: _SyntheticCallKey,
+    synthetic_call_ids: Mapping[_SyntheticCallKey, str],
+    path: str,
+) -> tuple[str, str | None]:
+    raw_call_id = raw_call.get("id")
+    if raw_call_id is None or raw_call_id == "":
+        try:
+            return synthetic_call_ids[key], None
+        except KeyError as exc:
+            raise DialectError(
+                f"{path} without a provider id has no synthetic correlation id"
+            ) from exc
+    if not isinstance(raw_call_id, str):
+        raise DialectError(f"{path}.id must be a string when present")
+    return raw_call_id, raw_call_id
+
+
+def _call_state_from_contents(
+    contents: Sequence[Mapping[str, JSONValue]],
+    synthetic_call_ids: Mapping[_SyntheticCallKey, str],
+) -> tuple[
+    dict[str, str],
+    set[str],
+    dict[str, str | None],
+    dict[str, str],
+]:
+    names: dict[str, str] = {}
+    answered: set[str] = set()
+    wire_ids: dict[str, str | None] = {}
+    pending_calls: dict[str, str] = {}
+    server_types: dict[str, str] = {}
+    answered_server_calls: set[str] = set()
+    for content_index, content in enumerate(contents):
+        role = content.get("role")
+        parts = content.get("parts")
+        if not isinstance(parts, list):
+            continue
+        turn_calls: dict[str, str] = {}
+        turn_responses: set[str] = set()
+        response_only_turn = True
+        for part_index, part in enumerate(parts):
+            if not isinstance(part, dict):
+                response_only_turn = False
+                continue
+            if set(part) & _OPAQUE_PART_FIELDS != {"functionResponse"}:
+                response_only_turn = False
+            call = part.get("functionCall")
+            if isinstance(call, dict):
+                if role != "model":
+                    raise DialectError(
+                        "Google functionCall history requires a model turn"
+                    )
+                call_id, wire_id = _local_call_id(
+                    call,
+                    (content_index, part_index, "functionCall"),
+                    synthetic_call_ids,
+                    "Google opaque functionCall",
+                )
+                name = call.get("name")
+                if not isinstance(name, str) or not name:
+                    raise DialectError(
+                        "Google opaque functionCall requires a non-empty name"
+                    )
+                if call_id in names:
+                    raise DialectError(f"duplicate Google function call id {call_id!r}")
+                names[call_id] = name
+                wire_ids[call_id] = wire_id
+                turn_calls[call_id] = name
+            response = part.get("functionResponse")
+            if isinstance(response, dict):
+                if role != "user":
+                    raise DialectError(
+                        "Google functionResponse history requires a user turn"
+                    )
+                call_id, _ = _local_call_id(
+                    response,
+                    (content_index, part_index, "functionResponse"),
+                    synthetic_call_ids,
+                    "Google opaque functionResponse",
+                )
+                name = response.get("name")
+                try:
+                    expected_name = names[call_id]
+                except KeyError as exc:
+                    raise DialectError(
+                        "Google opaque functionResponse at "
+                        f"{content_index}.{part_index} has no prior functionCall"
+                    ) from exc
+                if name != expected_name:
+                    raise DialectError(
+                        f"Google opaque functionResponse name changed for {call_id!r}"
+                    )
+                if call_id in answered:
+                    raise DialectError(
+                        f"duplicate Google function result for {call_id!r}"
+                    )
+                answered.add(call_id)
+                turn_responses.add(call_id)
+            server_call = part.get("toolCall")
+            if isinstance(server_call, dict):
+                call_id, _ = _local_call_id(
+                    server_call,
+                    (content_index, part_index, "toolCall"),
+                    synthetic_call_ids,
+                    "Google opaque toolCall",
+                )
+                tool_type = server_call.get("toolType")
+                if not isinstance(tool_type, str) or not tool_type:
+                    raise DialectError(
+                        "Google opaque toolCall requires a non-empty toolType"
+                    )
+                if call_id in server_types:
+                    raise DialectError(
+                        f"duplicate Google server tool call id {call_id!r}"
+                    )
+                server_types[call_id] = tool_type
+            server_response = part.get("toolResponse")
+            if not isinstance(server_response, dict):
+                continue
+            call_id, _ = _local_call_id(
+                server_response,
+                (content_index, part_index, "toolResponse"),
+                synthetic_call_ids,
+                "Google opaque toolResponse",
+            )
+            tool_type = server_response.get("toolType")
+            if not isinstance(tool_type, str) or not tool_type:
+                raise DialectError(
+                    "Google opaque toolResponse requires a non-empty toolType"
+                )
+            try:
+                expected_type = server_types[call_id]
+            except KeyError as exc:
+                raise DialectError(
+                    "Google opaque toolResponse at "
+                    f"{content_index}.{part_index} has no prior toolCall"
+                ) from exc
+            if tool_type != expected_type:
+                raise DialectError(
+                    f"Google opaque toolResponse type changed for {call_id!r}"
+                )
+            if call_id in answered_server_calls:
+                raise DialectError(
+                    f"duplicate Google server tool result for {call_id!r}"
+                )
+            answered_server_calls.add(call_id)
+
+        if pending_calls:
+            expected = set(pending_calls)
+            missing = sorted(expected - turn_responses)
+            unexpected = sorted(turn_responses - expected)
+            if role != "user" or not response_only_turn or missing or unexpected:
+                details: list[str] = []
+                if missing:
+                    details.append(
+                        "unanswered function call id(s): "
+                        + ", ".join(repr(call_id) for call_id in missing)
+                    )
+                if unexpected:
+                    details.append(
+                        "response id(s) outside the immediately preceding calls: "
+                        + ", ".join(repr(call_id) for call_id in unexpected)
+                    )
+                if role != "user" or not response_only_turn:
+                    details.append(
+                        "the next content turn must contain only matching "
+                        "functionResponse parts"
+                    )
+                raise DialectError(
+                    "Google function responses must immediately follow and exactly "
+                    "match the preceding function calls; " + "; ".join(details)
+                )
+            pending_calls = {}
+        elif turn_responses:
+            raise DialectError(
+                "Google functionResponse must answer the immediately preceding "
+                "model functionCall turn"
+            )
+
+        if turn_calls:
+            pending_calls = turn_calls
+    return names, answered, wire_ids, pending_calls
+
+
+def _require_answered_function_calls(
+    pending_calls: Mapping[str, str], path: str
+) -> None:
+    unanswered = sorted(pending_calls)
+    if unanswered:
+        rendered = ", ".join(repr(call_id) for call_id in unanswered)
+        raise DialectError(f"{path} has unanswered function call id(s): {rendered}")
+
+
+def _historical_output_call_ids(
+    contents: Sequence[Mapping[str, JSONValue]],
+    synthetic_call_ids: Mapping[_SyntheticCallKey, str],
+) -> tuple[frozenset[str], frozenset[str]]:
+    """Recover conversation-scoped call ids from the final request body."""
+
+    function_ids: set[str] = set()
+    server_ids: set[str] = set()
+    for content_index, content in enumerate(contents):
+        parts = content.get("parts")
+        if not isinstance(parts, list):
+            raise DialectError(
+                f"final Google contents[{content_index}].parts must be a list"
+            )
+        for part_index, part in enumerate(parts):
+            if not isinstance(part, Mapping):
+                raise DialectError(
+                    f"final Google contents[{content_index}].parts[{part_index}] "
+                    "must be an object"
+                )
+            for field_name, ids in (
+                ("functionCall", function_ids),
+                ("toolCall", server_ids),
+            ):
+                if field_name not in part:
+                    continue
+                call = part[field_name]
+                if not isinstance(call, Mapping):
+                    raise DialectError(
+                        f"final Google {field_name} history must be an object"
+                    )
+                call_id, _ = _local_call_id(
+                    cast(Mapping[str, object], call),
+                    (content_index, part_index, field_name),
+                    synthetic_call_ids,
+                    f"final Google {field_name} history",
+                )
+                if call_id in ids:
+                    raise DialectError(
+                        f"final Google history duplicates {field_name} id {call_id!r}"
+                    )
+                ids.add(call_id)
+    return frozenset(function_ids), frozenset(server_ids)
+
+
+def _chat_shape_error(request_input: ChatInput) -> str | None:
+    """Return a lossless-mapping error for Google chat history, if any."""
+
+    if not request_input.messages:
+        return "Google chat input must contain at least one message"
+    for message_index, message in enumerate(request_input.messages):
+        if message.role not in _CHAT_ROLES:
+            return f"Google message {message_index} has invalid role {message.role!r}"
+        for part_index, part in enumerate(message.content):
+            path = f"messages[{message_index}].content[{part_index}]"
+            if isinstance(part, TextPart):
+                if not isinstance(part.text, str):
+                    return f"{path}.text must be a string"
+            elif isinstance(part, ImagePart):
+                if (part.url is None) == (part.data is None):
+                    return f"{path} must contain exactly one of url or data"
+                if part.url is not None and not isinstance(part.url, str):
+                    return f"{path}.url must be a string"
+                if part.data is not None and not isinstance(part.data, str):
+                    return f"{path}.data must be a string"
+                if part.media_type is not None and not isinstance(part.media_type, str):
+                    return f"{path}.media_type must be a string"
+                if part.detail is not None and not isinstance(part.detail, str):
+                    return f"{path}.detail must be a string"
+            elif isinstance(part, ToolCallPart):
+                if not isinstance(part.call_id, str) or not part.call_id:
+                    return f"{path}.call_id must be a non-empty string"
+                if not isinstance(part.name, str) or not part.name:
+                    return f"{path}.name must be a non-empty string"
+                if not isinstance(part.arguments, Mapping):
+                    return f"{path}.arguments must be an object"
+            elif isinstance(part, ToolResultPart):
+                if not isinstance(part.call_id, str) or not part.call_id:
+                    return f"{path}.call_id must be a non-empty string"
+                if not isinstance(part.is_error, bool):
+                    return f"{path}.is_error must be a boolean"
+            else:
+                return f"{path} has unsupported type {type(part).__name__}"
+    if any(message.role == "developer" for message in request_input.messages):
+        return (
+            "Google systemInstruction cannot preserve the distinct developer "
+            "message authority"
+        )
+    if request_input.messages[-1].role == "assistant":
+        return "google_genai does not support assistant-prefill input"
+    return None
+
+
+def _require_generation_turn(contents: Sequence[JSONValue]) -> None:
+    """Reject a body that cannot ask Google for a new model turn."""
+
+    if not contents or _get(contents[-1], "role") != "user":
+        raise DialectError("Google contents must end with a user or tool-result turn")
+
+
+def _input_to_wire(
+    request_input: ChatInput, opaque: str | None
+) -> tuple[
+    dict[str, JSONValue] | None,
+    list[JSONValue],
+    dict[_SyntheticCallKey, str],
+]:
+    if error := _chat_shape_error(request_input):
+        raise DialectError(error)
+    system_parts: list[JSONValue] = []
+    opaque_system, opaque_contents, opaque_call_ids = (
+        _decode_opaque(opaque) if opaque is not None else (None, [], {})
+    )
+    contents: list[JSONValue] = list(opaque_contents)
+    synthetic_call_ids = dict(opaque_call_ids)
+    call_names, answered_calls, call_wire_ids, _ = _call_state_from_contents(
+        opaque_contents, synthetic_call_ids
+    )
+    saw_conversation = False
+    for message in request_input.messages:
+        if message.name is not None:
+            raise DialectError("Google contents have no ChatMessage.name field")
+        if message.role == "system":
+            if saw_conversation:
+                raise DialectError(
+                    "Google system/developer messages must precede conversation turns"
+                )
+            if any(not isinstance(part, TextPart) for part in message.content):
+                raise DialectError("Google systemInstruction is text-only")
+            parts = _content_parts(
+                message,
+                call_names,
+                answered_calls,
+                call_wire_ids,
+                synthetic_call_ids,
+                None,
+            )
+            system_parts.extend(parts)
+            continue
+        saw_conversation = True
+        content_index = len(contents)
+        parts = _content_parts(
+            message,
+            call_names,
+            answered_calls,
+            call_wire_ids,
+            synthetic_call_ids,
+            content_index,
+        )
+        role = "model" if message.role == "assistant" else "user"
+        contents.append({"role": role, "parts": parts})
+    _, _, _, pending_calls = _call_state_from_contents(
+        tuple(cast(list[Mapping[str, JSONValue]], contents)),
+        synthetic_call_ids,
+    )
+    _require_answered_function_calls(pending_calls, "Google conversation history")
+    _require_generation_turn(contents)
+    current_system: dict[str, JSONValue] | None = (
+        {"parts": system_parts} if system_parts else None
+    )
+    if (
+        opaque_system is not None
+        and current_system is not None
+        and opaque_system != current_system
+    ):
+        raise DialectError(
+            "Google opaque continuation systemInstruction conflicts with "
+            "the current request"
+        )
+    system = current_system if current_system is not None else opaque_system
+    return system, contents, synthetic_call_ids
+
+
+def _verification_input_to_wire(
+    request_input: ChatInput, opaque: str | None
+) -> tuple[dict[str, JSONValue] | None, list[JSONValue]]:
+    """Independently derive the expected input for request-audit verification."""
+
+    if error := _chat_shape_error(request_input):
+        raise DialectError(error)
+    opaque_system, opaque_contents, synthetic_call_ids = (
+        _decode_opaque(opaque) if opaque is not None else (None, [], {})
+    )
+    contents: list[JSONValue] = [
+        copy_json_value(item, "verified Google opaque content")
+        for item in opaque_contents
+    ]
+    system_parts: list[JSONValue] = []
+    call_names, answered, call_wire_ids, _ = _call_state_from_contents(
+        opaque_contents, synthetic_call_ids
+    )
+    saw_conversation = False
+
+    for message in request_input.messages:
+        if message.name is not None:
+            raise DialectError("Google contents have no ChatMessage.name field")
+        is_instruction = message.role == "system"
+        if is_instruction and saw_conversation:
+            raise DialectError(
+                "Google system/developer messages must precede conversation turns"
+            )
+        if not is_instruction:
+            saw_conversation = True
+
+        expected_parts: list[JSONValue] = []
+        for part in message.content:
+            if isinstance(part, TextPart):
+                if message.role == "tool":
+                    raise DialectError(
+                        "Google tool messages may contain only tool results"
+                    )
+                expected_parts.append({"text": part.text})
+                continue
+            if isinstance(part, ImagePart):
+                if message.role == "tool" or is_instruction:
+                    raise DialectError("Google instruction/tool messages are text-only")
+                if part.detail is not None:
+                    raise DialectError(
+                        "Google image parts have no per-image detail field"
+                    )
+                if (
+                    part.media_type is not None
+                    and part.media_type not in _IMAGE_MEDIA_TYPES
+                ):
+                    raise DialectError(
+                        f"unsupported Google image media type {part.media_type!r}"
+                    )
+                if part.url is not None:
+                    if not part.url:
+                        raise DialectError("Google image URLs must not be empty")
+                    file_data: dict[str, JSONValue] = {"fileUri": part.url}
+                    if part.media_type is not None:
+                        file_data["mimeType"] = part.media_type
+                    expected_parts.append({"fileData": file_data})
+                else:
+                    if not part.data or not part.media_type:
+                        raise DialectError(
+                            "Google inline images require data and MIME type"
+                        )
+                    expected_parts.append(
+                        {
+                            "inlineData": {
+                                "data": part.data,
+                                "mimeType": part.media_type,
+                            }
+                        }
+                    )
+                continue
+            if isinstance(part, ToolCallPart):
+                if message.role != "assistant":
+                    raise DialectError(
+                        "Google historical function calls require assistant role"
+                    )
+                if part.call_id in call_names:
+                    raise DialectError(
+                        f"duplicate Google function call id {part.call_id!r}"
+                    )
+                call_names[part.call_id] = part.name
+                call_wire_ids[part.call_id] = part.call_id
+                expected_parts.append(
+                    {
+                        "functionCall": {
+                            "id": part.call_id,
+                            "name": part.name,
+                            "args": copy_json_value(
+                                part.arguments, "verified function arguments"
+                            ),
+                        }
+                    }
+                )
+                continue
+            if isinstance(part, ToolResultPart):
+                if message.role != "tool":
+                    raise DialectError("Google function results require tool role")
+                if part.call_id not in call_names:
+                    raise DialectError(
+                        f"Google function result {part.call_id!r} has no prior call"
+                    )
+                if part.call_id in answered:
+                    raise DialectError(
+                        f"duplicate Google function result for {part.call_id!r}"
+                    )
+                answered.add(part.call_id)
+                raw_result = copy_json_value(
+                    part.result, "verified Google function response"
+                )
+                response: JSONValue
+                if part.is_error:
+                    response = {"error": raw_result}
+                elif isinstance(raw_result, dict):
+                    response = raw_result
+                else:
+                    response = {"result": raw_result}
+                function_response: dict[str, JSONValue] = {
+                    "name": call_names[part.call_id],
+                    "response": response,
+                }
+                wire_id = call_wire_ids[part.call_id]
+                if wire_id is not None:
+                    function_response["id"] = wire_id
+                expected_parts.append({"functionResponse": function_response})
+                if wire_id is None:
+                    synthetic_call_ids[
+                        (len(contents), len(expected_parts) - 1, "functionResponse")
+                    ] = part.call_id
+                continue
+            raise DialectError(f"unsupported Google content part {type(part).__name__}")
+
+        if not expected_parts:
+            raise DialectError("Google contents must not contain an empty message")
+        if is_instruction:
+            if any(not isinstance(part, TextPart) for part in message.content):
+                raise DialectError("Google systemInstruction is text-only")
+            system_parts.extend(expected_parts)
+        else:
+            role = "model" if message.role == "assistant" else "user"
+            contents.append({"role": role, "parts": expected_parts})
+
+    _, _, _, pending_calls = _call_state_from_contents(
+        tuple(cast(list[Mapping[str, JSONValue]], contents)),
+        synthetic_call_ids,
+    )
+    _require_answered_function_calls(
+        pending_calls, "verified Google conversation history"
+    )
+    _require_generation_turn(contents)
+    current_system: dict[str, JSONValue] | None = (
+        {"parts": system_parts} if system_parts else None
+    )
+    if (
+        opaque_system is not None
+        and current_system is not None
+        and opaque_system != current_system
+    ):
+        raise DialectError(
+            "Google opaque continuation systemInstruction conflicts with "
+            "the current request"
+        )
+    system = current_system if current_system is not None else opaque_system
+    return system, contents
+
+
+def _structured_output(req: Request, text: str) -> StructuredOutput | None:
+    if req.structured_output.format is None:
+        return None
+    try:
+        value = json.loads(
+            text,
+            object_pairs_hook=_reject_duplicate_keys,
+            parse_constant=_reject_json_constant,
+        )
+        return StructuredOutput(cast(JSONValue, value))
+    except (json.JSONDecodeError, TypeError, ValueError) as exc:
+        raise OutputContractError("Google structured output is not valid JSON") from exc
+
+
+def _usage(raw: object) -> UsageStats | None:
+    """Lift Google's counts onto the shared accounting.
+
+    Google reports the addends of ``totalTokenCount``; ``candidatesTokenCount``
+    excludes thoughts. Folding thoughts into ``output_tokens`` (and tool-use
+    prompt into ``input_tokens``) keeps ``reasoning_tokens`` a breakdown of its
+    parent. ``promptTokenCount`` already includes ``cachedContentTokenCount``.
+    """
+
+    if raw is None:
+        return None
+    if not isinstance(raw, Mapping):
+        raise OutputContractError("usageMetadata must be an object")
+    prompt = _nonnegative_int(_get(raw, "promptTokenCount"), "usage.promptTokenCount")
+    output = _nonnegative_int(
+        _get(raw, "candidatesTokenCount"), "usage.candidatesTokenCount"
+    )
+    thoughts = _optional_nonnegative_int(
+        _get(raw, "thoughtsTokenCount"), "usage.thoughtsTokenCount"
+    )
+    tool_use_prompt = _optional_nonnegative_int(
+        _get(raw, "toolUsePromptTokenCount"), "usage.toolUsePromptTokenCount"
+    )
+    reported_total = _optional_nonnegative_int(
+        _get(raw, "totalTokenCount"), "usage.totalTokenCount"
+    )
+    input_tokens = prompt + (tool_use_prompt or 0)
+    output_tokens = output + (thoughts or 0)
+    total = input_tokens + output_tokens
+    return UsageStats(
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        total_tokens=total,
+        reasoning_tokens=thoughts,
+        cached_tokens=(
+            _nonnegative_int(
+                _get(raw, "cachedContentTokenCount"), "usage.cachedContentTokenCount"
+            )
+            if _get(raw, "cachedContentTokenCount") is not None
+            else None
+        ),
+        reported_total_tokens=(
+            reported_total
+            if reported_total is not None and reported_total != total
+            else None
+        ),
+    )
+
+
+def _logprobs(
+    raw: object, path: str, requested_top_k: int
+) -> tuple[tuple[TokenLogprob, ...], tuple[tuple[TopKEntry, ...], ...]]:
+    chosen = _sequence(_get(raw, "chosenCandidates"), f"{path}.chosenCandidates")
+    raw_tops = _get(raw, "topCandidates")
+    tops = _sequence(raw_tops, f"{path}.topCandidates") if raw_tops is not None else ()
+    if requested_top_k > 0 and len(chosen) != len(tops):
+        raise OutputContractError("Google chosen/top logprob positions are misaligned")
+    if requested_top_k == 0 and tops and len(chosen) != len(tops):
+        raise OutputContractError("Google chosen/top logprob positions are misaligned")
+    sampled: list[TokenLogprob] = []
+    alternatives: list[tuple[TopKEntry, ...]] = []
+    for index, item in enumerate(chosen):
+        sampled.append(
+            TokenLogprob(
+                _required_string(_get(item, "token"), f"{path}.chosen[{index}].token"),
+                _finite_number(
+                    _get(item, "logProbability"),
+                    f"{path}.chosen[{index}].logProbability",
+                ),
+                _optional_nonnegative_int(
+                    _get(item, "tokenId"), f"{path}.chosen[{index}].tokenId"
+                ),
+            )
+        )
+        if not tops:
+            continue
+        entries = _sequence(_get(tops[index], "candidates"), f"{path}.top[{index}]")
+        if requested_top_k > 0 and len(entries) != requested_top_k:
+            raise OutputContractError(
+                "Google returned a different number of top logprobs than requested"
+            )
+        alternatives.append(
+            tuple(
+                TopKEntry(
+                    _required_string(_get(entry, "token"), f"{path}.top.token"),
+                    _finite_number(
+                        _get(entry, "logProbability"), f"{path}.top.logprob"
+                    ),
+                    _optional_nonnegative_int(
+                        _get(entry, "tokenId"), f"{path}.top.tokenId"
+                    ),
+                )
+                for entry in entries
+            )
+        )
+    return tuple(sampled), tuple(alternatives)
+
+
+def _citations(raw: object, path: str) -> list[Citation]:
+    if raw is None:
+        return []
+    if not isinstance(raw, Mapping):
+        raise OutputContractError(f"{path} must be an object")
+    result: list[Citation] = []
+    for index, source in enumerate(
+        _sequence(_get(raw, "citationSources", []), f"{path}.citationSources")
+    ):
+        uri = _get(source, "uri")
+        if uri is None:
+            raise OutputContractError(f"{path}[{index}].uri is absent")
+        result.append(Citation(_required_string(uri, f"{path}[{index}].uri")))
+    return result
+
+
+def _url_context_citations(raw: object, path: str) -> list[Citation]:
+    if raw is None:
+        return []
+    if not isinstance(raw, Mapping):
+        raise OutputContractError(f"{path} must be an object")
+    result: list[Citation] = []
+    for index, item in enumerate(
+        _sequence(_get(raw, "urlMetadata", []), f"{path}.urlMetadata")
+    ):
+        url = _get(item, "retrievedUrl")
+        if url is None:
+            raise OutputContractError(f"{path}.urlMetadata[{index}] omitted its URL")
+        result.append(Citation(_required_string(url, f"{path}.urlMetadata[{index}]")))
+    return result
+
+
+def _grounding(raw: object, path: str) -> GroundingMetadata | None:
+    if raw is None:
+        return None
+    if not isinstance(raw, Mapping):
+        raise OutputContractError(f"{path} must be an object")
+    chunks: list[GroundingChunk] = []
+    for index, chunk in enumerate(
+        _sequence(_get(raw, "groundingChunks", []), f"{path}.groundingChunks")
+    ):
+        sources = [
+            _get(chunk, name)
+            for name in ("web", "retrievedContext", "maps", "image")
+            if _get(chunk, name) is not None
+        ]
+        if len(sources) != 1:
+            raise OutputContractError(f"{path}.groundingChunks[{index}] is ambiguous")
+        source = sources[0]
+        uri = (
+            _get(source, "sourceUri", _get(source, "imageUri"))
+            if _get(chunk, "image") is not None
+            else _get(source, "uri")
+        )
+        if uri is None:
+            raise OutputContractError(
+                f"{path}.groundingChunks[{index}] has no representable URI"
+            )
+        chunks.append(
+            GroundingChunk(
+                _required_string(uri, f"{path}.groundingChunks[{index}].uri"),
+                _optional_string(
+                    _get(source, "title"), f"{path}.groundingChunks[{index}].title"
+                ),
+            )
+        )
+    entry = _get(raw, "searchEntryPoint")
+    rendered = _optional_string(
+        _get(entry, "renderedContent") if entry is not None else None,
+        f"{path}.searchEntryPoint.renderedContent",
+    )
+    return GroundingMetadata(tuple(chunks), rendered)
+
+
+def _prompt_block_reason(raw: object) -> str | None:
+    feedback = _get(raw, "promptFeedback")
+    if feedback is None:
+        return None
+    if not isinstance(feedback, Mapping):
+        raise OutputContractError("response.promptFeedback must be an object")
+    feedback_mapping = cast(Mapping[str, object], feedback)
+    if "blockReason" not in feedback_mapping:
+        return None
+    reason = feedback_mapping["blockReason"]
+    if not isinstance(reason, str) or not reason.strip():
+        raise OutputContractError(
+            "response.promptFeedback.blockReason must be a non-empty string"
+        )
+    return None if reason == "BLOCK_REASON_UNSPECIFIED" else reason
+
+
+def _merge_stream_grounding_metadata(
+    accumulated: dict[str, object] | None,
+    incoming: object,
+    path: str,
+) -> dict[str, object]:
+    """Merge Google streaming grounding metadata without losing prior evidence."""
+
+    if not isinstance(incoming, Mapping):
+        raise OutputContractError(f"{path} must be an object")
+    result: dict[str, object] = {} if accumulated is None else accumulated
+    for raw_name, value in incoming.items():
+        if not isinstance(raw_name, str):
+            raise OutputContractError(f"{path} field names must be strings")
+        if value is None:
+            continue
+        if raw_name in {"groundingChunks", "groundingSupports"}:
+            target = result.get(raw_name)
+            if target is None:
+                new_target: list[object] = []
+                result[raw_name] = new_target
+                target = new_target
+            if not isinstance(target, list):
+                raise AssertionError("Google grounding accumulator changed shape")
+            cast(list[object], target).extend(_sequence(value, f"{path}.{raw_name}"))
+            continue
+        previous = result.get(raw_name)
+        if previous is not None and previous != value:
+            raise OutputContractError(
+                f"Google stream changed {path}.{raw_name} between events"
+            )
+        result[raw_name] = value
+    return result
+
+
+def _merge_stream_text_delta(
+    previous: object, current: object
+) -> dict[str, object] | None:
+    """Join wire text deltas only while they remain one semantic part."""
+
+    if not isinstance(previous, Mapping) or not isinstance(current, Mapping):
+        return None
+    previous_mapping = cast(Mapping[str, object], previous)
+    current_mapping = cast(Mapping[str, object], current)
+    allowed = {"text", "thought", "thoughtSignature"}
+    if set(previous_mapping) - allowed or set(current_mapping) - allowed:
+        return None
+    previous_text = previous_mapping.get("text")
+    current_text = current_mapping.get("text")
+    if not isinstance(previous_text, str) or not isinstance(current_text, str):
+        return None
+    if previous_mapping.get("thought") != current_mapping.get("thought"):
+        return None
+    previous_signature = previous_mapping.get("thoughtSignature")
+    current_signature = current_mapping.get("thoughtSignature")
+    # A signature closes the prior semantic part. A signature delivered with
+    # the next delta belongs to the part formed by joining that delta backward.
+    if previous_signature is not None:
+        return None
+    if current_signature is not None and (
+        not isinstance(current_signature, str) or not current_signature
+    ):
+        return None
+    merged = dict(previous_mapping)
+    merged["text"] = previous_text + current_text
+    if "thought" in current_mapping:
+        merged["thought"] = current_mapping["thought"]
+    if current_signature is not None:
+        merged["thoughtSignature"] = current_signature
+    return merged
+
+
+def _append_stream_parts(
+    accumulated: list[object], incoming: object, path: str
+) -> None:
+    parts = list(_sequence(incoming, path))
+    if accumulated and parts:
+        merged = _merge_stream_text_delta(accumulated[-1], parts[0])
+        if merged is not None:
+            accumulated[-1] = merged
+            parts.pop(0)
+    accumulated.extend(parts)
+
+
+def _synthetic_call_id(
+    input_contents: Sequence[Mapping[str, JSONValue]],
+    candidate_index: int,
+    part_index: int,
+    kind: str,
+    name: str,
+    arguments: Mapping[str, JSONValue],
+) -> str:
+    """Derive a stable IR id when Google omits an optional call id."""
+
+    payload = {
+        "input_contents": list(input_contents),
+        "candidate_index": candidate_index,
+        "part_index": part_index,
+        "kind": kind,
+        "name": name,
+        "arguments": dict(arguments),
+    }
+    encoded = json.dumps(
+        payload,
+        ensure_ascii=False,
+        allow_nan=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    prefix = "google_call" if kind == "function" else "google_server"
+    return f"{prefix}_{hashlib.sha256(encoded).hexdigest()[:24]}"
+
+
+def _opaque_history(
+    system_instruction: Mapping[str, JSONValue] | None,
+    input_contents: Sequence[Mapping[str, JSONValue]],
+    input_synthetic_call_ids: Mapping[_SyntheticCallKey, str],
+    output_content: Mapping[str, JSONValue],
+    opaque_call_ids: Mapping[int, tuple[str, str]],
+) -> str | None:
+    history: list[JSONValue] = [
+        copy_json_value(item, "Google input history") for item in input_contents
+    ]
+    copied_output = copy_json_value(output_content, "Google output history")
+    if not isinstance(copied_output, dict):
+        raise AssertionError("copied Google output content must remain an object")
+    copied_parts = copied_output.get("parts")
+    if not isinstance(copied_parts, list):
+        raise AssertionError("copied Google output content must retain parts")
+    synthetic_call_ids = dict(input_synthetic_call_ids)
+    output_content_index = len(history)
+    for part_index, (field_name, call_id) in opaque_call_ids.items():
+        try:
+            copied_part = copied_parts[part_index]
+        except IndexError as exc:
+            raise AssertionError("Google function-call part index changed") from exc
+        if not isinstance(copied_part, dict):
+            raise AssertionError("Google function-call part changed shape")
+        copied_call = copied_part.get(field_name)
+        if not isinstance(copied_call, dict):
+            raise AssertionError("Google call payload changed shape")
+        copied_id = copied_call.get("id")
+        if copied_id is not None and copied_id != "":
+            raise AssertionError("synthetic Google call unexpectedly gained an id")
+        synthetic_call_ids[(output_content_index, part_index, field_name)] = call_id
+    history.append(copied_output)
+    if (
+        not _has_thought_signature(cast(Sequence[Mapping[str, JSONValue]], history))
+        and not synthetic_call_ids
+    ):
+        return None
+    envelope: dict[str, JSONValue] = {
+        "version": _OPAQUE_VERSION,
+        "contents": history,
+    }
+    if system_instruction is not None:
+        envelope["systemInstruction"] = copy_json_value(
+            system_instruction, "Google system history"
+        )
+    if synthetic_call_ids:
+        envelope["syntheticCallIds"] = [
+            {
+                "contentIndex": content_index,
+                "partIndex": part_index,
+                "field": field_name,
+                "id": call_id,
+            }
+            for (content_index, part_index, field_name), call_id in sorted(
+                synthetic_call_ids.items()
+            )
+        ]
+    return json.dumps(
+        envelope,
+        ensure_ascii=False,
+        allow_nan=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+
+
+class GoogleGenAIDialect:
+    """Executable adapter for Gemini native generateContent REST endpoints."""
+
+    dialect_id = "google_genai"
+    connection_family = "async_http_json"
+    capability_decisions = CAPABILITY_DECISIONS
+    output_contract = OUTPUT_CONTRACT
+    CAPABILITIES = frozenset(
+        {
+            Capability.Chat,
+            Capability.FunctionCalling,
+            Capability.ServerTools,
+            Capability.Reasoning,
+            Capability.ReasoningEffort,
+            Capability.SampledLogprobs,
+            Capability.StructuredOutput,
+            Capability.TopKLogprobs,
+        }
+    )
+
+    def __init__(self, connection: object, requested_model_id: str):
+        if not isinstance(connection, AsyncHTTPJSONConnection):
+            raise TypeError("google_genai requires AsyncHTTPJSONConnection")
+        if not requested_model_id:
+            raise ValueError("requested_model_id must not be empty")
+        model_name = requested_model_id.removeprefix("models/")
+        if not model_name or "/" in model_name:
+            raise ValueError(
+                "requested_model_id must be a Gemini model id or models/<id>"
+            )
+        self._connection = connection
+        self._requested_model_id = requested_model_id
+        self._model_name = model_name
+        self._wire_contract, self._endpoint_root = resolve_wire_endpoint(
+            connection.client.base_url
+        )
+
+    @property
+    def capabilities(self) -> frozenset[Capability]:
+        return self.CAPABILITIES
+
+    def validate_request(
+        self, req: Request, audit: RequestAudit, plan: RuntimePlanView
+    ) -> None:
+        audit.require_matches_request(req)
+        del plan
+        constraints = _model_request_constraints(self._model_name)
+        tool_combination_error = _tool_combination_error(
+            self._model_name,
+            constraints,
+            has_functions=bool(req.tools.functions),
+            has_hosted=bool(req.tools.hosted),
+        )
+        chat_shape_error = (
+            _chat_shape_error(req.input) if isinstance(req.input, ChatInput) else None
+        )
+        invalid_option_paths = (
+            {
+                f"dialect_options.{key}"
+                for key in req.dialect_options.values
+                if not isinstance(key, str)
+            }
+            if req.dialect_options is not None
+            else set()
+        )
+        for path in audit.active_paths:
+            if path == "input.chat":
+                if chat_shape_error is not None:
+                    audit.rejected(path, chat_shape_error)
+            elif path == "input.chat.message.name":
+                audit.rejected(path, "Google contents have no ChatMessage.name field")
+            elif path.startswith("input.completion"):
+                audit.rejected(path, "google_genai requires ChatInput")
+            elif path == "input.modality.image.detail":
+                audit.rejected(path, "Google images have no per-image detail field")
+            elif path == "scoring.input_scoring":
+                audit.rejected(path, "Gemini cannot score input tokens")
+            elif (
+                path in _GEMINI_3_SAMPLING_PATHS and constraints.omit_sampling_controls
+            ):
+                audit.rejected(
+                    path,
+                    "Google's Gemini 3 guidance says to omit temperature, top_p, "
+                    f"and top_k for {self._model_name}",
+                )
+            elif path == "sampling.temperature" and not (
+                0 <= cast(float, req.sampling.temperature) <= 2
+            ):
+                audit.rejected(path, "Google temperature must be between 0 and 2")
+            elif path == "sampling.top_p" and not (
+                0 <= cast(float, req.sampling.top_p) <= 1
+            ):
+                audit.rejected(path, "Google top_p must be between 0 and 1")
+            elif path == "sampling.top_k" and cast(int, req.sampling.top_k) < 1:
+                audit.rejected(path, "Google top_k must be positive")
+            elif (
+                path == "sampling.top_k" and cast(int, req.sampling.top_k) > _INT32_MAX
+            ):
+                audit.rejected(path, "Google top_k must fit a signed 32-bit integer")
+            elif (
+                path == "sampling.max_tokens" and cast(int, req.sampling.max_tokens) < 1
+            ):
+                audit.rejected(path, "Google max_tokens must be positive")
+            elif (
+                path == "sampling.max_tokens"
+                and cast(int, req.sampling.max_tokens) > _INT32_MAX
+            ):
+                audit.rejected(
+                    path,
+                    "Google max_tokens must fit a signed 32-bit integer",
+                )
+            elif path == "sampling.seed" and not (
+                _INT32_MIN <= cast(int, req.sampling.seed) <= _INT32_MAX
+            ):
+                audit.rejected(path, "Google seed must fit a signed 32-bit integer")
+            elif path == "sampling.n" and req.sampling.n > _INT32_MAX:
+                audit.rejected(path, "Google n must fit a signed 32-bit integer")
+            elif (
+                path == "sampling.n"
+                and req.sampling.n > 1
+                and constraints.maximum_candidates == 1
+            ):
+                audit.rejected(
+                    path, "Gemini 3 models do not support candidateCount greater than 1"
+                )
+            elif (
+                path == "sampling.stop"
+                and len(cast(tuple[str, ...], req.sampling.stop)) > 5
+            ):
+                audit.rejected(path, "Google supports at most five stop sequences")
+            elif path == "scoring.top_logprobs" and req.scoring.top_logprobs > 20:
+                audit.rejected(path, "Gemini supports at most 20 top logprobs")
+            elif path == "reasoning.effort" and (
+                not isinstance(req.reasoning.effort, str)
+                or req.reasoning.effort.lower() not in _THINKING_LEVELS
+            ):
+                audit.rejected(path, "unsupported Google thinking level")
+            elif path == "reasoning.effort" and (
+                error := _thinking_level_error(
+                    self._model_name,
+                    constraints,
+                    cast(str, req.reasoning.effort),
+                )
+            ):
+                audit.rejected(path, error)
+            elif path == "reasoning.summary" and req.reasoning.summary not in {
+                "none",
+                "auto",
+            }:
+                audit.rejected(path, "Google supports only summary='none' or 'auto'")
+            elif (
+                path == "reasoning.budget_tokens"
+                and cast(int, req.reasoning.budget_tokens) > _INT32_MAX
+            ):
+                audit.rejected(
+                    path,
+                    "Google reasoning budget_tokens must fit a signed 32-bit integer",
+                )
+            elif path == "reasoning.budget_tokens" and (
+                error := _thinking_budget_error(
+                    self._model_name,
+                    constraints,
+                    cast(int, req.reasoning.budget_tokens),
+                )
+            ):
+                audit.rejected(path, error)
+            elif path == "tools.parallel":
+                audit.rejected(path, "Google has no per-request parallel tool switch")
+            elif (
+                path in {"tools.functions", "tools.hosted"}
+                and tool_combination_error is not None
+            ):
+                audit.rejected(path, tool_combination_error)
+            elif path == "tools.functions":
+                try:
+                    for function in req.tools.functions:
+                        _function_declaration(function, self._wire_contract)
+                except DialectError as exc:
+                    audit.rejected(path, str(exc))
+            elif path == "tools.choice" and not req.tools.functions:
+                audit.rejected(path, "Google tool choice requires function tools")
+            elif path == "tools.hosted":
+                for tool in req.tools.hosted:
+                    error = _hosted_tool_config_error(tool.kind, tool.config)
+                    if error is not None:
+                        audit.rejected(path, error)
+                        break
+            elif path == "session.previous_response_id":
+                audit.rejected(path, "Gemini responseId is not a continuation handle")
+            elif (
+                path == "structured_output.format"
+                and req.structured_output.format
+                not in {
+                    "json_object",
+                    "json_schema",
+                }
+            ):
+                audit.rejected(path, "unsupported Google structured output format")
+            elif path == "structured_output.schema" and (
+                req.structured_output.format != "json_schema"
+            ):
+                audit.rejected(
+                    path, "Google response schema requires format='json_schema'"
+                )
+            elif path == "structured_output.name":
+                audit.rejected(path, "Google response JSON schemas have no name field")
+            elif path == "structured_output.strict":
+                audit.rejected(path, "Google exposes no JSON-schema strict switch")
+            elif path.startswith("dialect_options."):
+                key = path.removeprefix("dialect_options.")
+                if path in invalid_option_paths:
+                    audit.rejected(path, "Google dialect option keys must be strings")
+                elif not key:
+                    audit.rejected(path, "dialect option keys must be non-empty")
+                elif key in _IR_OWNED_KEYS:
+                    audit.rejected(path, f"{key!r} must use its provider-neutral field")
+                elif key in self._wire_contract.unavailable_fields.get("request", ()):
+                    audit.rejected(
+                        path,
+                        f"{key!r} is unavailable in Google "
+                        f"{self._wire_contract.api_version}",
+                    )
+
+    def prepare(self, req: Request, audit: RequestAudit) -> PreparedRequest:
+        audit.require_matches_request(req)
+        audit.raise_rejections()
+        if not isinstance(req.input, ChatInput):
+            raise DialectError("google_genai requires ChatInput")
+        if error := _tool_combination_error(
+            self._model_name,
+            _model_request_constraints(self._model_name),
+            has_functions=bool(req.tools.functions),
+            has_hosted=bool(req.tools.hosted),
+        ):
+            raise DialectError(error)
+        active = frozenset(audit.active_paths)
+
+        def consume(path: str, *evidence: WireEvidence) -> None:
+            if path in active and path not in audit.decisions:
+                audit.consumed(path, *evidence)
+
+        opaque = (
+            req.session.opaque_continuation.value
+            if req.session.opaque_continuation is not None
+            else None
+        )
+        input_verifier = _InputVerifier.from_request(req.input, opaque)
+        operation_verifier = _OperationVerifier(
+            self._model_name,
+            self._wire_contract.api_version,
+            req.scheduling.stream,
+        )
+        system, contents, synthetic_call_ids = _input_to_wire(req.input, opaque)
+        body: dict[str, JSONValue] = {"contents": contents}
+        if system is not None:
+            body["systemInstruction"] = system
+        _validate_server_tool_history_signatures(body, self._model_name)
+        consume(
+            "input.chat", input_verifier, PreparedRequestEvidence(operation_verifier)
+        )
+        for path in (
+            "input.modality.text",
+            "input.modality.image",
+            "input.modality.image.media_type",
+            "input.modality.tool_call",
+            "input.modality.tool_result",
+            "input.modality.tool_result.is_error",
+        ):
+            consume(path, input_verifier)
+        if opaque is not None:
+            consume("session.opaque_continuation", input_verifier)
+
+        generation: dict[str, JSONValue] = {}
+        sampling = req.sampling
+        fields = {
+            "temperature": "temperature",
+            "top_p": "topP",
+            "top_k": "topK",
+            "max_tokens": "maxOutputTokens",
+            "stop": "stopSequences",
+            "seed": "seed",
+            "frequency_penalty": "frequencyPenalty",
+            "presence_penalty": "presencePenalty",
+            "n": "candidateCount",
+        }
+        for source, destination in fields.items():
+            value = getattr(sampling, source)
+            default = getattr(type(sampling)(), source)
+            if value != default:
+                generation[destination] = (
+                    list(value) if isinstance(value, tuple) else value
+                )
+                consume(
+                    f"sampling.{source}",
+                    WireObservation(("generationConfig", destination)),
+                )
+
+        if req.scoring.sampled_logprobs:
+            generation["responseLogprobs"] = True
+            consume(
+                "scoring.sampled_logprobs",
+                WireObservation(("generationConfig", "responseLogprobs")),
+            )
+        if req.scoring.top_logprobs > 0:
+            generation["logprobs"] = req.scoring.top_logprobs
+            consume(
+                "scoring.top_logprobs",
+                WireObservation(("generationConfig", "logprobs")),
+            )
+
+        thinking: dict[str, JSONValue] = {}
+        if req.reasoning.effort is not None:
+            thinking["thinkingLevel"] = req.reasoning.effort.upper()
+            consume("reasoning.effort", _ThinkingEffortVerifier(req.reasoning.effort))
+        if req.reasoning.budget_tokens is not None:
+            thinking["thinkingBudget"] = req.reasoning.budget_tokens
+            consume(
+                "reasoning.budget_tokens",
+                WireObservation(
+                    ("generationConfig", "thinkingConfig", "thinkingBudget")
+                ),
+            )
+        if req.reasoning.summary == "none":
+            audit.noop(
+                "reasoning.summary", "omitting includeThoughts requests no thoughts"
+            )
+        elif req.reasoning.summary == "auto":
+            thinking["includeThoughts"] = True
+            consume(
+                "reasoning.summary",
+                _ReasoningSummaryVerifier(),
+            )
+        if thinking:
+            generation["thinkingConfig"] = thinking
+
+        if req.structured_output.format is not None:
+            generation["responseMimeType"] = "application/json"
+            consume(
+                "structured_output.format",
+                _StructuredFormatVerifier(req.structured_output.format),
+            )
+        if req.structured_output.schema is not None:
+            generation["responseJsonSchema"] = dict(req.structured_output.schema)
+            consume(
+                "structured_output.schema",
+                WireObservation(("generationConfig", "responseJsonSchema")),
+            )
+        if generation:
+            body["generationConfig"] = generation
+
+        tools: list[JSONValue] = []
+        if req.tools.functions:
+            tools.append(
+                {
+                    "functionDeclarations": [
+                        _function_declaration(item, self._wire_contract)
+                        for item in req.tools.functions
+                    ]
+                }
+            )
+            consume(
+                "tools.functions",
+                _FunctionsVerifier(req.tools.functions, self._wire_contract),
+            )
+        if req.tools.hosted:
+            tools.extend(_hosted_tool(tool) for tool in req.tools.hosted)
+            consume(
+                "tools.hosted",
+                _HostedToolsVerifier(
+                    req.tools.hosted, has_functions=bool(req.tools.functions)
+                ),
+            )
+        if tools:
+            body["tools"] = tools
+        if req.tools.choice is not None:
+            tool_config = _tool_choice(
+                req.tools.choice,
+                include_server_side_invocations=bool(req.tools.hosted),
+            )
+            allowed = _get(
+                _get(tool_config, "functionCallingConfig"),
+                "allowedFunctionNames",
+                [],
+            )
+            declared = {
+                _get(_function_declaration_source(item), "name")
+                for item in req.tools.functions
+            }
+            if any(name not in declared for name in _sequence(allowed, "tool choice")):
+                raise DialectError("Google tool choice names an undeclared function")
+            body["toolConfig"] = tool_config
+            consume(
+                "tools.choice",
+                _ToolChoiceVerifier(
+                    req.tools.choice,
+                    include_server_side_invocations=bool(req.tools.hosted),
+                ),
+            )
+        if req.tools.hosted:
+            existing_tool_config = body.get("toolConfig")
+            if existing_tool_config is None:
+                merged_tool_config: dict[str, JSONValue] = {}
+            elif isinstance(existing_tool_config, Mapping):
+                merged_tool_config = dict(existing_tool_config)
+            else:
+                raise AssertionError("Google toolConfig must remain an object")
+            merged_tool_config["includeServerSideToolInvocations"] = True
+            body["toolConfig"] = merged_tool_config
+
+        options = req.dialect_options
+        if options is not None:
+            if not options.values:
+                audit.noop(
+                    "dialect_options", "empty matching options have no wire semantics"
+                )
+            for key, value in options.values.items():
+                if not isinstance(key, str):
+                    raise DialectError("Google dialect option keys must be strings")
+                path = f"dialect_options.{key}"
+                if path in audit.decisions:
+                    continue
+                body[key] = value
+                audit.consumed(path, _RootOptionVerifier(key, value))
+
+        validate_wire_body(body, self._wire_contract)
+        method = "streamGenerateContent" if req.scheduling.stream else "generateContent"
+        operation = (
+            f"{self._wire_contract.api_version}/models/"
+            f"{quote(self._model_name, safe='')}:{method}"
+        )
+        if req.scheduling.stream:
+            operation = f"{operation}?alt=sse"
+        if req.scheduling.stream:
+            consume(
+                "scheduling.stream",
+                PreparedRequestEvidence(operation_verifier),
+            )
+        return PreparedRequest(
+            operation,
+            body,
+            _GoogleContext(deepcopy(req), synthetic_call_ids),
+        )
+
+    def _lift(self, raw: object, context: _GoogleExecutionContext) -> Response:
+        req = context.request
+        prior_opaque = (
+            req.session.opaque_continuation.value
+            if req.session.opaque_continuation is not None
+            else None
+        )
+        block_reason = _prompt_block_reason(raw)
+        raw_candidates = _get(raw, "candidates")
+        candidates = (
+            ()
+            if raw_candidates is None and block_reason is not None
+            else _sequence(raw_candidates, "response.candidates")
+        )
+        if block_reason is not None:
+            if candidates:
+                raise OutputContractError(
+                    "Google response is contradictory: prompt was blocked "
+                    f"with reason {block_reason}, but candidates were returned"
+                )
+            return Response(
+                texts=("",) * req.sampling.n,
+                finish_reasons=(block_reason,) * req.sampling.n,
+                finish_reason_sources=(FINISH_SOURCE_PROMPT_BLOCK,) * req.sampling.n,
+                usage=_usage(_get(raw, "usageMetadata")),
+                request_params=context.request_params,
+                response_model=_optional_string(
+                    _get(raw, "modelVersion"), "response.modelVersion"
+                ),
+            )
+        if len(candidates) != req.sampling.n:
+            raise OutputContractError(
+                f"expected {req.sampling.n} Google candidates, "
+                f"received {len(candidates)}"
+            )
+        texts: list[str] = []
+        finish_reasons: list[str] = []
+        reasoning: list[ReasoningOutput | None] = []
+        saw_thought_parts: list[bool] = []
+        calls: list[FunctionToolCall] = []
+        call_ids = set(context.historical_function_call_ids)
+        server_call_ids = set(context.historical_server_call_ids)
+        server_calls: dict[str, tuple[str, Mapping[str, JSONValue]]] = {}
+        server_results: dict[str, tuple[str, JSONValue]] = {}
+        citations: list[Citation] = []
+        groundings: list[GroundingMetadata] = []
+        sampled: list[TokenLogprob] = []
+        top: list[tuple[TopKEntry, ...]] = []
+        saw_logprobs = False
+        allowed_function_names = _allowed_function_call_names(req)
+        allowed_server_tool_types = _allowed_server_tool_types(req)
+        require_server_signatures = (
+            _GEMINI_3_MODEL_PATTERN.match(self._model_name) is not None
+            and _get(
+                _get(_get(context.request_params, "body"), "toolConfig"),
+                "includeServerSideToolInvocations",
+            )
+            is True
+        )
+        for index, candidate in enumerate(candidates):
+            candidate_index = _get(candidate, "index", index)
+            if candidate_index != index:
+                raise OutputContractError("Google candidate indexes are not ordered")
+            finish_reason = _required_string(
+                _get(candidate, "finishReason"), "candidate.finishReason"
+            )
+            if finish_reason == "FINISH_REASON_UNSPECIFIED":
+                raise OutputContractError("Google candidate is not terminal")
+            fatal_message = _FATAL_FINISH_REASON_MESSAGES.get(finish_reason)
+            if fatal_message is not None:
+                raise OutputContractError(fatal_message)
+            finish_reasons.append(finish_reason)
+            content = _get(candidate, "content")
+            if content is None:
+                content_mapping: Mapping[str, JSONValue] | None = None
+                parts: Sequence[object] = ()
+            elif isinstance(content, Mapping):
+                content_mapping = cast(Mapping[str, JSONValue], content)
+                unknown_content = set(content_mapping) - {"role", "parts"}
+                if unknown_content:
+                    raise OutputContractError(
+                        "Google response content has unsupported field(s): "
+                        + ", ".join(sorted(unknown_content))
+                    )
+                role = content_mapping.get("role")
+                if role is not None and role != "model":
+                    raise OutputContractError(
+                        "Google response content role is not model"
+                    )
+                parts = _sequence(
+                    content_mapping.get("parts"), f"candidates[{index}].parts"
+                )
+            else:
+                raise OutputContractError("Google response content must be an object")
+            text_parts: list[str] = []
+            thought_text: list[str] = []
+            opaque_call_ids: dict[int, tuple[str, str]] = {}
+            saw_function_call = False
+            for part_index, raw_part in enumerate(parts):
+                if not isinstance(raw_part, Mapping):
+                    raise OutputContractError("Google response part must be an object")
+                part = cast(Mapping[str, JSONValue], raw_part)
+                unknown_part = set(part) - (
+                    _OPAQUE_PART_FIELDS
+                    | _PART_AUXILIARY_FIELDS
+                    | {"thought", "thoughtSignature"}
+                )
+                if unknown_part:
+                    raise OutputContractError(
+                        "Google response part has unsupported field(s): "
+                        + ", ".join(sorted(unknown_part))
+                    )
+                if error := _part_auxiliary_error(
+                    part, f"candidates[{index}].parts[{part_index}]"
+                ):
+                    raise OutputContractError(error)
+                thought_marker = part.get("thought")
+                if thought_marker is not None and not isinstance(thought_marker, bool):
+                    raise OutputContractError(
+                        "Google response thought marker must be boolean"
+                    )
+                signature = part.get("thoughtSignature")
+                if signature is not None and (
+                    not isinstance(signature, str) or not signature
+                ):
+                    raise OutputContractError(
+                        "Google response thoughtSignature must be a non-empty string"
+                    )
+                if require_server_signatures:
+                    error = _server_tool_signature_error(
+                        part, f"candidates[{index}].parts[{part_index}]"
+                    )
+                    if error is not None:
+                        raise OutputContractError(error)
+                known = [
+                    name
+                    for name in ("text", "functionCall", "toolCall", "toolResponse")
+                    if name in part
+                ]
+                if part.get("thought") is True:
+                    if known != ["text"] or not isinstance(part.get("text"), str):
+                        raise OutputContractError(
+                            "Google thought part must contain exactly one text field"
+                        )
+                    thought_text.append(cast(str, part["text"]))
+                    continue
+                if len(known) != 1:
+                    raise OutputContractError(
+                        f"candidates[{index}].parts[{part_index}] has unsupported shape"
+                    )
+                if known[0] == "text":
+                    text_parts.append(_string(part["text"], "response text"))
+                elif known[0] == "functionCall":
+                    is_first_function_call = not saw_function_call
+                    saw_function_call = True
+                    raw_call = part["functionCall"]
+                    if not isinstance(raw_call, Mapping):
+                        raise OutputContractError("functionCall must be an object")
+                    call = cast(Mapping[str, object], raw_call)
+                    arguments = copy_json_value(
+                        _get(call, "args", {}), "functionCall.args"
+                    )
+                    if not isinstance(arguments, dict):
+                        raise OutputContractError("functionCall.args must be an object")
+                    name = _required_string(_get(call, "name"), "functionCall.name")
+                    if name not in allowed_function_names:
+                        if not req.tools.functions:
+                            raise OutputContractError(
+                                "Google returned an unrequested function call"
+                            )
+                        raise OutputContractError(
+                            f"Google returned function {name!r} outside the "
+                            "request's allowed function set"
+                        )
+                    raw_call_id = _get(call, "id")
+                    if raw_call_id is None or raw_call_id == "":
+                        if _requires_exact_function_call_ids(self._model_name):
+                            raise OutputContractError(
+                                f"{self._model_name} response omitted the required "
+                                "functionCall.id"
+                            )
+                        call_id = _synthetic_call_id(
+                            context.input_contents,
+                            index,
+                            part_index,
+                            "function",
+                            name,
+                            arguments,
+                        )
+                    elif isinstance(raw_call_id, str):
+                        call_id = raw_call_id
+                    else:
+                        raise OutputContractError(
+                            "functionCall.id must be a string when present"
+                        )
+                    if (
+                        is_first_function_call
+                        and _GEMINI_3_MODEL_PATTERN.match(self._model_name) is not None
+                        and signature is None
+                    ):
+                        raise OutputContractError(
+                            f"{self._model_name} function-call response omitted "
+                            "the required thoughtSignature on its first "
+                            "functionCall part"
+                        )
+                    if call_id in call_ids:
+                        raise OutputContractError(
+                            f"duplicate Google function call id {call_id!r}"
+                        )
+                    call_ids.add(call_id)
+                    if raw_call_id is None or raw_call_id == "":
+                        opaque_call_ids[part_index] = ("functionCall", call_id)
+                    calls.append(
+                        FunctionToolCall(
+                            call_id,
+                            name,
+                            arguments,
+                        )
+                    )
+                elif known[0] == "toolCall":
+                    raw_item = part["toolCall"]
+                    if not isinstance(raw_item, Mapping):
+                        raise OutputContractError("toolCall must be an object")
+                    item = cast(Mapping[str, object], raw_item)
+                    tool_type = _required_string(
+                        _get(item, "toolType"), "toolCall.toolType"
+                    )
+                    raw_tool_id = _get(item, "id")
+                    raw_args = copy_json_value(_get(item, "args", {}), "toolCall.args")
+                    if not isinstance(raw_args, dict):
+                        raise OutputContractError("toolCall.args must be an object")
+                    if raw_tool_id is None or raw_tool_id == "":
+                        tool_id = _synthetic_call_id(
+                            context.input_contents,
+                            index,
+                            part_index,
+                            "server",
+                            tool_type,
+                            raw_args,
+                        )
+                    elif isinstance(raw_tool_id, str):
+                        tool_id = raw_tool_id
+                    else:
+                        raise OutputContractError(
+                            "toolCall.id must be a string when present"
+                        )
+                    if tool_type not in allowed_server_tool_types:
+                        if not req.tools.hosted:
+                            raise OutputContractError(
+                                "Google returned an unrequested server tool call"
+                            )
+                        raise OutputContractError(
+                            f"Google returned server tool type {tool_type!r} "
+                            "outside the request's allowed hosted-tool set"
+                        )
+                    if tool_id in server_call_ids:
+                        raise OutputContractError(
+                            f"duplicate Google server tool call id {tool_id!r}"
+                        )
+                    server_call_ids.add(tool_id)
+                    server_calls[tool_id] = (tool_type, raw_args)
+                    if raw_tool_id is None or raw_tool_id == "":
+                        opaque_call_ids[part_index] = ("toolCall", tool_id)
+                else:
+                    if not req.tools.hosted:
+                        raise OutputContractError(
+                            "Google returned an unrequested server tool response"
+                        )
+                    raw_item = part["toolResponse"]
+                    if not isinstance(raw_item, Mapping):
+                        raise OutputContractError("toolResponse must be an object")
+                    item = cast(Mapping[str, object], raw_item)
+                    tool_type = _required_string(
+                        _get(item, "toolType"), "toolResponse.toolType"
+                    )
+                    raw_tool_id = _get(item, "id")
+                    if raw_tool_id is None or raw_tool_id == "":
+                        matching = [
+                            call_id
+                            for call_id, (call_type, _) in server_calls.items()
+                            if call_type == tool_type and call_id not in server_results
+                        ]
+                        if len(matching) != 1:
+                            raise OutputContractError(
+                                "Google toolResponse without id is ambiguous"
+                            )
+                        tool_id = matching[0]
+                    elif isinstance(raw_tool_id, str):
+                        tool_id = raw_tool_id
+                    else:
+                        raise OutputContractError(
+                            "toolResponse.id must be a string when present"
+                        )
+                    if tool_id in server_results:
+                        raise OutputContractError(
+                            f"duplicate Google server tool response id {tool_id!r}"
+                        )
+                    tool_result = copy_json_value(
+                        _get(item, "response"), "toolResponse.response"
+                    )
+                    if not isinstance(tool_result, dict):
+                        raise OutputContractError(
+                            "toolResponse.response must be an object"
+                        )
+                    server_results[tool_id] = (tool_type, tool_result)
+                    if raw_tool_id is None or raw_tool_id == "":
+                        opaque_call_ids[part_index] = ("toolResponse", tool_id)
+            text = "".join(text_parts)
+            texts.append(text)
+            if content_mapping is not None and parts:
+                opaque = _opaque_history(
+                    context.system_instruction,
+                    context.input_contents,
+                    context.synthetic_call_ids,
+                    content_mapping,
+                    opaque_call_ids,
+                )
+            else:
+                # No provider part means there is no new state to append.  The
+                # previous signed history is still the exact continuation state,
+                # including when thinking consumes the output budget before a
+                # visible part is emitted.
+                opaque = prior_opaque
+            saw_thought_parts.append(bool(thought_text))
+            reasoning.append(
+                ReasoningOutput(
+                    text="\n".join(thought_text) or None,
+                    opaque_roundtrip=opaque,
+                )
+                if thought_text or opaque is not None
+                else None
+            )
+            citations.extend(
+                _citations(_get(candidate, "citationMetadata"), "citationMetadata")
+            )
+            citations.extend(
+                _url_context_citations(
+                    _get(candidate, "urlContextMetadata"), "urlContextMetadata"
+                )
+            )
+            grounding = _grounding(
+                _get(candidate, "groundingMetadata"), "groundingMetadata"
+            )
+            if grounding is not None:
+                groundings.append(grounding)
+            raw_logprobs = _get(candidate, "logprobsResult")
+            if req.scoring.sampled_logprobs:
+                if raw_logprobs is None:
+                    if finish_reason in _CHANNEL_OPTIONAL_FINISH_REASONS:
+                        continue
+                    raise OutputContractError("Google reply omitted requested logprobs")
+                saw_logprobs = True
+                chosen, alternatives = _logprobs(
+                    raw_logprobs,
+                    "candidate.logprobsResult",
+                    req.scoring.top_logprobs,
+                )
+                if text and not chosen:
+                    raise OutputContractError(
+                        "Google returned non-empty text without chosen logprobs"
+                    )
+                sampled.extend(chosen)
+                top.extend(alternatives)
+        if req.reasoning.summary == "auto":
+            for finish_reason, reasoning_item, saw_thought in zip(
+                finish_reasons, reasoning, saw_thought_parts, strict=True
+            ):
+                if (
+                    finish_reason not in _CHANNEL_OPTIONAL_FINISH_REASONS
+                    and saw_thought
+                    and (
+                        reasoning_item is None
+                        or reasoning_item.text is None
+                        or not reasoning_item.text.strip()
+                    )
+                ):
+                    raise OutputContractError(
+                        "Google reply returned an empty requested thought summary"
+                    )
+        if req.sampling.n > 1 and (citations or groundings):
+            raise OutputContractError(
+                "Google singular citation/grounding metadata cannot represent choices"
+            )
+        if len(groundings) > 1:
+            raise OutputContractError(
+                "multiple candidates returned singular grounding metadata"
+            )
+        text = texts[0] if len(texts) == 1 else ""
+        server_uses: list[ServerToolUse] = []
+        for tool_id, (tool_type, tool_input) in server_calls.items():
+            result_entry = server_results.pop(tool_id, None)
+            if result_entry is not None and result_entry[0] != tool_type:
+                raise OutputContractError(
+                    f"Google server tool type changed for {tool_id!r}"
+                )
+            server_uses.append(
+                ServerToolUse(
+                    tool_type=tool_type,
+                    tool_use_id=tool_id,
+                    input=tool_input,
+                    result=None if result_entry is None else result_entry[1],
+                )
+            )
+        if server_results:
+            raise OutputContractError(
+                "Google returned a server tool response without its call"
+            )
+        all_channels_optional = bool(finish_reasons) and all(
+            reason in _CHANNEL_OPTIONAL_FINISH_REASONS for reason in finish_reasons
+        )
+        return Response(
+            texts=tuple(texts),
+            reasoning=(
+                tuple(reasoning)
+                if any(reasoning) or req.reasoning.summary == "auto"
+                else None
+            ),
+            finish_reasons=tuple(finish_reasons),
+            finish_reason_sources=(FINISH_SOURCE_CANDIDATE,) * len(finish_reasons),
+            tool_calls=tuple(calls) or None,
+            server_tool_uses=tuple(server_uses) or None,
+            structured_output=(
+                None if all_channels_optional else _structured_output(req, text)
+            ),
+            logprobs=(
+                tuple(sampled)
+                if req.scoring.sampled_logprobs and saw_logprobs
+                else None
+            ),
+            top_logprobs=(
+                tuple(top) if req.scoring.top_logprobs > 0 and saw_logprobs else None
+            ),
+            citations=tuple(citations) or None,
+            grounding=groundings[0] if groundings else None,
+            usage=_usage(_get(raw, "usageMetadata")),
+            request_params=context.request_params,
+            response_model=_optional_string(
+                _get(raw, "modelVersion"), "response.modelVersion"
+            ),
+        )
+
+    async def _lift_stream(
+        self, response: httpx.Response, context: _GoogleExecutionContext
+    ) -> Response:
+        chunks: list[object] = []
+        data_lines: list[str] = []
+
+        def flush_event() -> None:
+            if not data_lines:
+                return
+            payload = "\n".join(data_lines)
+            data_lines.clear()
+            event = _strict_json_loads(payload, "Google stream event")
+            if not isinstance(event, dict) or not event:
+                raise OutputContractError(
+                    "Google stream event must be a non-empty response object"
+                )
+            chunks.append(event)
+
+        async for line in response.aiter_lines():
+            if not line:
+                flush_event()
+                continue
+            if line.startswith(":"):
+                continue
+            field, separator, value = line.partition(":")
+            if not separator:
+                raise OutputContractError("Google stream emitted a malformed SSE line")
+            if field == "data":
+                data_lines.append(value.removeprefix(" "))
+            elif field not in {"event", "id", "retry"}:
+                raise OutputContractError(
+                    f"Google stream emitted unsupported SSE field {field!r}"
+                )
+        flush_event()
+        if not chunks:
+            raise OutputContractError("Google stream emitted no response chunks")
+        return self._merge_stream(chunks, context)
+
+    def _merge_stream(
+        self, chunks: list[object], context: _GoogleExecutionContext
+    ) -> Response:
+        # Each stream event carries candidate deltas plus cumulative/terminal
+        # metadata. Merge only provider-defined additive content; usage is a
+        # terminal snapshot and must come from the final event.
+        by_index: dict[int, dict[str, object]] = {}
+        model_version: object = None
+        prompt_feedback: object = None
+        for chunk_index, chunk in enumerate(chunks):
+            if _get(chunk, "modelVersion") is not None:
+                current_model = _get(chunk, "modelVersion")
+                if model_version is not None and current_model != model_version:
+                    raise OutputContractError(
+                        "Google stream changed modelVersion between events"
+                    )
+                model_version = current_model
+            current_feedback = _get(chunk, "promptFeedback")
+            if current_feedback is not None:
+                _prompt_block_reason(chunk)
+                if prompt_feedback is not None and current_feedback != prompt_feedback:
+                    raise OutputContractError(
+                        "Google stream changed promptFeedback between events"
+                    )
+                prompt_feedback = current_feedback
+            for raw_candidate in _sequence(
+                _get(chunk, "candidates", []), f"stream[{chunk_index}].candidates"
+            ):
+                index = _get(
+                    raw_candidate,
+                    "index",
+                    0 if context.request.sampling.n == 1 else None,
+                )
+                if isinstance(index, bool) or not isinstance(index, int) or index < 0:
+                    raise OutputContractError(
+                        "Google stream candidate index is invalid"
+                    )
+                state = by_index.setdefault(index, {"parts": []})
+                if "finishReason" in state:
+                    raise OutputContractError(
+                        f"Google stream emitted candidate {index} after its "
+                        "terminal finishReason"
+                    )
+                content = _get(raw_candidate, "content")
+                if content is not None:
+                    role = _get(content, "role")
+                    if role is not None and role != "model":
+                        raise OutputContractError(
+                            "Google stream candidate role is not model"
+                        )
+                    _append_stream_parts(
+                        cast(list[object], state["parts"]),
+                        _get(content, "parts", []),
+                        "stream candidate parts",
+                    )
+                finish_reason = _get(raw_candidate, "finishReason")
+                if finish_reason is not None:
+                    state["finishReason"] = finish_reason
+                for name in ("citationMetadata", "urlContextMetadata"):
+                    value = _get(raw_candidate, name)
+                    if value is not None:
+                        previous = state.get(name)
+                        if previous is not None and previous != value:
+                            raise OutputContractError(
+                                f"Google stream changed {name} between events"
+                            )
+                        state[name] = value
+                raw_grounding = _get(raw_candidate, "groundingMetadata")
+                if raw_grounding is not None:
+                    accumulated_grounding = state.get("groundingMetadata")
+                    if accumulated_grounding is not None and not isinstance(
+                        accumulated_grounding, dict
+                    ):
+                        raise AssertionError(
+                            "Google grounding accumulator changed type"
+                        )
+                    state["groundingMetadata"] = _merge_stream_grounding_metadata(
+                        cast(dict[str, object] | None, accumulated_grounding),
+                        raw_grounding,
+                        "groundingMetadata",
+                    )
+                raw_logprobs = _get(raw_candidate, "logprobsResult")
+                if raw_logprobs is not None:
+                    if not isinstance(raw_logprobs, Mapping):
+                        raise OutputContractError(
+                            "Google stream logprobsResult must be an object"
+                        )
+                    accumulated_raw = state.get("logprobsResult")
+                    if accumulated_raw is None:
+                        accumulated: dict[str, object] = {
+                            "chosenCandidates": [],
+                            "topCandidates": [],
+                        }
+                        state["logprobsResult"] = accumulated
+                    elif isinstance(accumulated_raw, dict):
+                        accumulated = cast(dict[str, object], accumulated_raw)
+                    else:
+                        raise AssertionError("Google logprobs accumulator changed type")
+                    for field_name in ("chosenCandidates", "topCandidates"):
+                        value = _get(raw_logprobs, field_name)
+                        if value is not None:
+                            target = accumulated.get(field_name)
+                            if not isinstance(target, list):
+                                raise AssertionError(
+                                    "Google logprobs accumulator changed shape"
+                                )
+                            cast(list[object], target).extend(
+                                _sequence(
+                                    value,
+                                    f"stream logprobsResult.{field_name}",
+                                )
+                            )
+        candidates: list[JSONValue] = []
+        for index in sorted(by_index):
+            state = by_index[index]
+            candidate: dict[str, JSONValue] = {
+                "index": index,
+                "content": {
+                    "role": "model",
+                    "parts": cast(list[JSONValue], state.pop("parts")),
+                },
+            }
+            for key, value in state.items():
+                candidate[key] = copy_json_value(value, f"stream.{key}")
+            candidates.append(candidate)
+        merged: dict[str, JSONValue] = {"candidates": candidates}
+        terminal_usage = _get(chunks[-1], "usageMetadata")
+        if terminal_usage is not None:
+            merged["usageMetadata"] = copy_json_value(
+                terminal_usage, "terminal stream usage"
+            )
+        if model_version is not None:
+            merged["modelVersion"] = copy_json_value(model_version, "stream model")
+        if prompt_feedback is not None:
+            merged["promptFeedback"] = copy_json_value(
+                prompt_feedback, "stream promptFeedback"
+            )
+        return self._lift(merged, context)
+
+    async def execute(self, prepared: PreparedRequest) -> Response:
+        context = prepared.context
+        if not isinstance(context, _GoogleContext):
+            raise DialectError("google_genai received invalid prepared context")
+        operation_verifier = _OperationVerifier(
+            self._model_name,
+            self._wire_contract.api_version,
+            context.request.scheduling.stream,
+        )
+        operation_mismatch = operation_verifier.verify_prepared(prepared)
+        if operation_mismatch is not None:
+            raise DialectError(
+                f"google_genai received the wrong prepared operation: "
+                f"{operation_mismatch}"
+            )
+        body = prepared.thaw_body()
+        raw_contents = body.get("contents")
+        if not isinstance(raw_contents, list):
+            raise DialectError("prepared Google request has invalid contents")
+        copied_contents = copy_json_value(raw_contents, "prepared Google contents")
+        if not isinstance(copied_contents, list) or not all(
+            isinstance(item, dict) for item in copied_contents
+        ):
+            raise DialectError("prepared Google request has invalid content items")
+        headers = {"Content-Type": "application/json"}
+        credential = self._connection.credential
+        if credential is not None:
+            headers["x-goog-api-key"] = credential
+        request = self._connection.client.build_request(
+            "POST",
+            self._endpoint_root.join(prepared.operation),
+            headers=headers,
+            json=body,
+        )
+        operation_verifier.verify_http(request, self._endpoint_root)
+        actual_body = _strict_json_loads(
+            request.content.decode("utf-8"), "final Google request body"
+        )
+        if not isinstance(actual_body, dict):
+            raise DialectError("final Google request body must be an object")
+        validate_wire_body(actual_body, self._wire_contract)
+        mismatch = _FunctionsVerifier(
+            context.request.tools.functions, self._wire_contract
+        ).verify(actual_body)
+        if mismatch is not None:
+            raise DialectError(f"final Google request: {mismatch}")
+        _validate_final_request_constraints(actual_body, self._model_name)
+        actual_contents = actual_body.get("contents")
+        if not isinstance(actual_contents, list) or not all(
+            isinstance(item, dict) for item in actual_contents
+        ):
+            raise DialectError("final Google request body has invalid contents")
+        actual_content_tuple = tuple(
+            cast(list[Mapping[str, JSONValue]], actual_contents)
+        )
+        _, _, _, pending_calls = _call_state_from_contents(
+            actual_content_tuple,
+            context.synthetic_call_ids,
+        )
+        _require_answered_function_calls(
+            pending_calls, "final Google conversation history"
+        )
+        historical_function_call_ids, historical_server_call_ids = (
+            _historical_output_call_ids(
+                actual_content_tuple,
+                context.synthetic_call_ids,
+            )
+        )
+        raw_system = actual_body.get("systemInstruction")
+        if raw_system is None:
+            actual_system: Mapping[str, JSONValue] | None = None
+        elif isinstance(raw_system, dict):
+            actual_system = cast(Mapping[str, JSONValue], raw_system)
+        else:
+            raise DialectError(
+                "final Google request body has invalid systemInstruction"
+            )
+        request_params: dict[str, JSONValue] = {
+            "method": request.method,
+            "path": request.url.path,
+            "body": {
+                key: value
+                for key, value in actual_body.items()
+                if key not in {"contents", "systemInstruction"}
+            },
+        }
+        actual_alt = request.url.params.get("alt")
+        if actual_alt is not None:
+            request_params["query"] = {"alt": actual_alt}
+        execution_context = _GoogleExecutionContext(
+            request=context.request,
+            request_params=request_params,
+            system_instruction=actual_system,
+            input_contents=actual_content_tuple,
+            synthetic_call_ids=context.synthetic_call_ids,
+            historical_function_call_ids=historical_function_call_ids,
+            historical_server_call_ids=historical_server_call_ids,
+        )
+        if context.request.scheduling.stream:
+            response = await self._connection.client.send(request, stream=True)
+            try:
+                if not response.is_success:
+                    await response.aread()
+                response.raise_for_status()
+                return await self._lift_stream(response, execution_context)
+            finally:
+                await response.aclose()
+        response = await self._connection.client.send(request)
+        response.raise_for_status()
+        payload = _strict_json_loads(response.text, "Google response body")
+        return self._lift(payload, execution_context)
+
+    async def arun(self, req: Request) -> Response:
+        plan = _LegacyPlan()
+        validate_request_invariants(req)
+        validate_runtime_binding_plan(plan, req)
+        audit = RequestAudit(active_request_leaves(req))
+        self.validate_request(req, audit, plan)
+        audit.raise_rejections()
+        prepared = self.prepare(req, audit)
+        audit.finish(prepared)
+        response = await self.execute(prepared)
+        self.output_contract.validate(plan, req, response)
+        return response
+
+
+@dataclass(frozen=True)
+class _RootOptionVerifier:
+    key: str
+    value: JSONValue
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "value",
+            copy_json_value(self.value, f"Google dialect option {self.key}"),
+        )
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        return (
+            None
+            if self.key in body and body[self.key] == self.value
+            else f"Google dialect option {self.key!r} changed"
+        )
+
+
+@dataclass(frozen=True)
+class _ThinkingEffortVerifier:
+    effort: str
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        actual = _get(
+            _get(_get(body, "generationConfig"), "thinkingConfig"), "thinkingLevel"
+        )
+        return None if actual == self.effort.upper() else "thinking level changed"
+
+
+@dataclass(frozen=True)
+class _ReasoningSummaryVerifier:
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        actual = _get(
+            _get(_get(body, "generationConfig"), "thinkingConfig"),
+            "includeThoughts",
+        )
+        return None if actual is True else "visible-thought request changed"
+
+
+@dataclass(frozen=True)
+class _StructuredFormatVerifier:
+    format: str
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        generation = _get(body, "generationConfig")
+        if _get(generation, "responseMimeType") != "application/json":
+            return "structured output MIME type changed"
+        has_schema = _get(generation, "responseJsonSchema") is not None
+        if has_schema != (self.format == "json_schema"):
+            return "structured output schema presence changed"
+        return None
+
+
+@dataclass(frozen=True)
+class _FunctionsVerifier:
+    functions: tuple[Mapping[str, JSONValue], ...]
+    contract: GoogleWireContract
+
+    def __post_init__(self) -> None:
+        copied: list[Mapping[str, JSONValue]] = []
+        for index, function in enumerate(self.functions):
+            item = copy_json_value(function, f"Google function {index}")
+            if not isinstance(item, dict):
+                raise TypeError("Google function declarations must be objects")
+            copied.append(item)
+        object.__setattr__(self, "functions", tuple(copied))
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        declarations: list[JSONValue] = []
+        for function in self.functions:
+            source = dict(function)
+            nested = source.get("function")
+            if source.get("type") == "function" and isinstance(nested, dict):
+                source = dict(nested)
+            else:
+                source.pop("type", None)
+            declaration: dict[str, JSONValue] = {"name": source.get("name")}
+            if "description" in source:
+                declaration["description"] = source["description"]
+            if "parameters" in source:
+                declaration["parametersJsonSchema"] = source["parameters"]
+            declarations.append(declaration)
+        # Inspect actual declarations; never run the lowering encoder on the
+        # source schema. In v1, decode only Schema nodes before comparison.
+        tools = body.get("tools", [])
+        if not isinstance(tools, Sequence) or isinstance(tools, str | bytes):
+            return "function tools changed"
+        actual: list[JSONValue] = []
+        saw_declarations = False
+        for tool in tools:
+            if not isinstance(tool, Mapping) or "functionDeclarations" not in tool:
+                continue
+            if (
+                saw_declarations
+                or not self.functions
+                or set(tool) != {"functionDeclarations"}
+            ):
+                return "function tools changed"
+            saw_declarations = True
+            raw_declarations = _get(tool, "functionDeclarations")
+            if not isinstance(raw_declarations, Sequence) or isinstance(
+                raw_declarations, str | bytes
+            ):
+                return "function tools changed"
+            for raw in raw_declarations:
+                if not isinstance(raw, Mapping):
+                    return "function tools changed"
+                try:
+                    declaration = dict(
+                        cast(Mapping[str, JSONValue], copy_json_value(raw, "function"))
+                    )
+                except (TypeError, ValueError):
+                    return "function tools changed"
+                selected = self.contract.function_schema_field
+                other = (
+                    "parametersJsonSchema" if selected == "parameters" else "parameters"
+                )
+                if other in declaration:
+                    return "function tools changed"
+                if selected in declaration and selected == "parameters":
+                    try:
+                        declaration["parametersJsonSchema"] = inspect_function_schema(
+                            declaration.pop("parameters")
+                        )
+                    except DialectError:
+                        return "function tools changed"
+                actual.append(declaration)
+        # JSON comparison distinguishes booleans from numeric constraints.
+        return (
+            None
+            if json.dumps(actual, sort_keys=True)
+            == json.dumps(declarations, sort_keys=True)
+            else "function tools changed"
+        )
+
+
+@dataclass(frozen=True)
+class _HostedToolsVerifier:
+    hosted: tuple[object, ...]
+    has_functions: bool = False
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        tools = _get(body, "tools")
+        expected: list[dict[str, JSONValue]] = []
+        for item in self.hosted:
+            kind = getattr(item, "kind", None)
+            config = getattr(item, "config", None)
+            if not isinstance(config, Mapping):
+                return "hosted tool config is invalid"
+            key = "googleSearch" if kind == "google_search" else "urlContext"
+            expected.append({key: dict(config)})
+        if not isinstance(tools, Sequence) or isinstance(tools, str | bytes):
+            return "hosted tools changed"
+        if self.has_functions:
+            if (
+                not tools
+                or not isinstance(tools[0], Mapping)
+                or set(tools[0]) != {"functionDeclarations"}
+            ):
+                return "hosted tools changed"
+            actual = tools[1:]
+        else:
+            actual = tools
+        try:
+            matches = json.dumps(
+                copy_json_value(actual, "verified Google hosted tools"), sort_keys=True
+            ) == json.dumps(
+                copy_json_value(expected, "requested Google hosted tools"),
+                sort_keys=True,
+            )
+        except (TypeError, ValueError):
+            matches = False
+        if not matches:
+            return "hosted tools changed"
+        if (
+            _get(_get(body, "toolConfig"), "includeServerSideToolInvocations")
+            is not True
+        ):
+            return "hosted-tool invocation evidence was disabled"
+        return None
+
+
+@dataclass(frozen=True)
+class _ToolChoiceVerifier:
+    choice: JSONValue
+    include_server_side_invocations: bool = False
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        if isinstance(self.choice, str):
+            mode = {
+                "auto": (
+                    "VALIDATED" if self.include_server_side_invocations else "AUTO"
+                ),
+                "none": "NONE",
+                "required": "ANY",
+            }.get(self.choice)
+            expected: JSONValue = {"functionCallingConfig": {"mode": mode}}
+        elif isinstance(self.choice, dict):
+            nested = self.choice.get("function")
+            name = (
+                nested.get("name")
+                if isinstance(nested, dict)
+                else self.choice.get("name")
+            )
+            expected = {
+                "functionCallingConfig": {
+                    "mode": "ANY",
+                    "allowedFunctionNames": [name],
+                }
+            }
+        else:
+            return "source tool choice is invalid"
+        actual = _get(body, "toolConfig")
+        if not isinstance(actual, Mapping):
+            return "tool choice changed"
+        actual_choice = {
+            key: value
+            for key, value in actual.items()
+            if key != "includeServerSideToolInvocations"
+        }
+        return None if actual_choice == expected else "tool choice changed"
diff --git a/sieval/core/models/ir.py b/sieval/core/models/ir.py
index bede408c..391e10c9 100644
--- a/sieval/core/models/ir.py
+++ b/sieval/core/models/ir.py
@@ -514,6 +514,13 @@ class ModelProvenance:
 _CHOICE_CHANNEL = {"response_role": "channel", "choice_indexed": True}
 _SINGULAR_CHANNEL = {"response_role": "channel", "choice_indexed": False}
 _PROVENANCE = {"response_role": "provenance", "choice_indexed": False}
+_CHOICE_PROVENANCE = {"response_role": "provenance", "choice_indexed": True}
+
+#: ``Response.finish_reason_sources`` values. Persisted in records, so the
+#: spellings are frozen; :func:`sieval.core.utils.meta.is_truncated_finish_reason`
+#: keys on them.
+FINISH_SOURCE_CANDIDATE = "candidate.finishReason"
+FINISH_SOURCE_PROMPT_BLOCK = "promptFeedback.blockReason"
 
 
 @sieval_record
@@ -560,6 +567,9 @@ class Response:
     response_model: str | None = field(default=None, metadata=_PROVENANCE)
     system_fingerprint: str | None = field(default=None, metadata=_PROVENANCE)
     provenance: ModelProvenance | None = field(default=None, metadata=_PROVENANCE)
+    finish_reason_sources: tuple[str, ...] | None = field(
+        default=None, metadata=_CHOICE_PROVENANCE
+    )
 
     def __post_init__(self) -> None:
         if self.request_params is not None:
@@ -570,6 +580,13 @@ def __post_init__(self) -> None:
             self.texts
         ):
             raise ValueError("Response.finish_reasons must align with Response.texts")
+        if self.finish_reason_sources is not None and (
+            self.finish_reasons is None
+            or len(self.finish_reason_sources) != len(self.finish_reasons)
+        ):
+            raise ValueError(
+                "Response.finish_reason_sources must align with Response.finish_reasons"
+            )
 
 
 def response_field_contract() -> dict[str, tuple[str, bool]]:
diff --git a/sieval/core/tasks/anomaly.py b/sieval/core/tasks/anomaly.py
index 6dbeed8a..cba94feb 100644
--- a/sieval/core/tasks/anomaly.py
+++ b/sieval/core/tasks/anomaly.py
@@ -17,7 +17,7 @@
 from sieval.core.models import ModelOutput
 from sieval.core.tasks.context import TaskContext, TaskStage, TaskStageOutput
 from sieval.core.tasks.records import is_prediction_record
-from sieval.core.utils.meta import TRUNCATION_FINISH_REASONS
+from sieval.core.utils.meta import is_truncated_finish_reason
 
 
 # Schema
@@ -471,31 +471,32 @@ def detect_empty_infer_ppl(ctx: TaskContext) -> set[int]:
 
 
 @sieval_detection_rule(
-    description="Output was truncated due to length limit",
+    description="Output was interrupted before completion",
     category="output_quality",
     rationale=(
-        "Truncated outputs may indicate insufficient max_tokens setting "
-        "or unexpectedly long responses. Scoped to gen: single-token logprob "
+        "A token limit, output filter, or refusal cut the output short; only "
+        "a token limit is fixed by raising max_tokens. Scoped to gen: "
+        "single-token logprob "
         "tasks (ppl/clp) infer with max_tokens=1 and always finish with "
         "'length', so the signal is only meaningful for generation."
     ),
     severity="info",
     applies_to=["gen"],
-    tags=["truncation", "length_limit", "incomplete_output"],
+    tags=["truncation", "length_limit", "output_filter", "incomplete_output"],
 )
 def detect_truncated_output(ctx: TaskContext) -> set[int]:
     if ctx.infer_result is None:
         return set()
-    # Unioned across calls: a conversation whose second turn hit the cap has that
-    # rollout truncated, whichever turn did it. The reason set is shared with the
-    # `n_truncated` report key -- which reduces the same event off the persisted
-    # `finish_reasons` rather than the live output -- so the two cannot drift.
-    return {
-        i
-        for output in _model_outputs(_unwrap_result(ctx.infer_result))
-        for i, reason in enumerate(output.finish_reasons or ())
-        if reason in TRUNCATION_FINISH_REASONS
-    }
+    # Unioned across calls: whichever turn was cut short, the rollout was. The
+    # predicate is shared with the `n_truncated` report key so the two cannot drift.
+    truncated: set[int] = set()
+    for output in _model_outputs(_unwrap_result(ctx.infer_result)):
+        sources = output.finish_reason_sources or ()
+        for index, reason in enumerate(output.finish_reasons or ()):
+            source = sources[index] if index < len(sources) else None
+            if is_truncated_finish_reason(reason, source):
+                truncated.add(index)
+    return truncated
 
 
 @sieval_detection_rule(
diff --git a/sieval/core/utils/meta.py b/sieval/core/utils/meta.py
index 01d962e3..4fca68f0 100644
--- a/sieval/core/utils/meta.py
+++ b/sieval/core/utils/meta.py
@@ -6,29 +6,63 @@
 from packaging.version import InvalidVersion, Version
 
 from sieval import __version__
-from sieval.core.models import ModelCallMeta, ModelOutput
+from sieval.core.models import (
+    FINISH_SOURCE_CANDIDATE,
+    FINISH_SOURCE_PROMPT_BLOCK,
+    ModelCallMeta,
+    ModelOutput,
+)
 from sieval.core.tasks.consts import TaskStage
 from sieval.core.tasks.context import TaskStageMeta
 
-#: Finish reasons that mean the generation stopped before the model chose to.
-#:
-#: Every spelling, not one canonical name: the IR does not normalize these, so a
-#: set holding only ``length`` (OpenAI-compatible Chat/Completions and SGLang
-#: native) would read zero against ``max_output_tokens`` (OpenAI Responses) or
-#: ``max_tokens`` or ``model_context_window_exceeded`` (Anthropic).
-#: ``content_filter`` is in because the output is cut short the same way;
-#: separating causes is what the raw ``finish_reasons`` are for. Shared with
-#: :func:`sieval.core.tasks.anomaly.detect_truncated_output` so the rule and the
-#: report key cannot drift apart.
-TRUNCATION_FINISH_REASONS = frozenset(
+#: Google candidate policy stops. ``promptFeedback.blockReason`` can use the
+#: same spellings, so these count only with a candidate source.
+_GOOGLE_POLICY_FINISH_REASONS = frozenset(
     {
-        "length",
-        "max_output_tokens",
-        "max_tokens",
-        "model_context_window_exceeded",
-        "content_filter",
+        "SAFETY",
+        "RECITATION",
+        "LANGUAGE",
+        "BLOCKLIST",
+        "PROHIBITED_CONTENT",
+        "SPII",
+        "IMAGE_SAFETY",
+        "IMAGE_PROHIBITED_CONTENT",
+        "IMAGE_RECITATION",
+        "ESCALATION",
     }
 )
+#: Finish reasons for output interrupted by a limit, filter, or refusal. Every
+#: provider spelling is listed because the IR does not normalize them. Shared by
+#: the anomaly rule and the report key so the two cannot drift.
+_TRUNCATION_FINISH_REASONS = (
+    frozenset(
+        {
+            "length",
+            "max_output_tokens",
+            "max_tokens",
+            "model_context_window_exceeded",
+            "MAX_TOKENS",
+            "CONTINUATION",
+            "content_filter",
+            "refusal",
+        }
+    )
+    | _GOOGLE_POLICY_FINISH_REASONS
+)
+
+
+def is_truncated_finish_reason(reason: str, source: str | None = None) -> bool:
+    """Whether ``reason`` (from ``source``, if recorded) interrupted the output.
+
+    Google policy stops need a candidate source: a record that predates
+    ``finish_reason_sources`` cannot tell them from a prompt block, so they are
+    left uncounted.
+    """
+    if source == FINISH_SOURCE_PROMPT_BLOCK:
+        return False
+    return reason in _TRUNCATION_FINISH_REASONS and (
+        reason not in _GOOGLE_POLICY_FINISH_REASONS or source == FINISH_SOURCE_CANDIDATE
+    )
 
 
 def build_model_call_meta(output: ModelOutput) -> ModelCallMeta:
@@ -40,6 +74,8 @@ def build_model_call_meta(output: ModelOutput) -> ModelCallMeta:
         model_call["request_params"] = dict(output.request_params)
     if output.finish_reasons:
         model_call["finish_reasons"] = output.finish_reasons
+    if output.finish_reason_sources is not None:
+        model_call["finish_reason_sources"] = list(output.finish_reason_sources)
     if output.response_model is not None:
         model_call["response_model"] = output.response_model
     if output.system_fingerprint is not None:
@@ -71,6 +107,9 @@ def build_model_call_meta_from_mapping(data: Mapping) -> ModelCallMeta | None:
     finish_reasons = data.get("finish_reasons")
     if finish_reasons:
         call["finish_reasons"] = list(finish_reasons)
+    finish_reason_sources = data.get("finish_reason_sources")
+    if finish_reason_sources is not None:
+        call["finish_reason_sources"] = list(finish_reason_sources)
     for key in ("response_model", "system_fingerprint"):
         value = data.get(key)
         if value is not None:
@@ -189,9 +228,11 @@ def _scored_rollout_indices(
     scored: set[int] = set()
     truncated: set[int] = set()
     for call in entries[-1].get("model_calls") or ():
+        sources = call.get("finish_reason_sources") or ()
         for index, reason in enumerate(call.get("finish_reasons") or ()):
             scored.add(index)
-            if reason in TRUNCATION_FINISH_REASONS:
+            source = sources[index] if index < len(sources) else None
+            if is_truncated_finish_reason(reason, source):
                 truncated.add(index)
     return scored, truncated
 
@@ -199,11 +240,10 @@ def _scored_rollout_indices(
 def count_truncated_rollouts(
     stage_metas: Iterable[Mapping[str, list]],
 ) -> int | None:
-    """Rollouts whose generation was cut short, over a report's scored records.
+    """Rollouts whose output was interrupted, over a report's scored records.
 
-    A truncated rollout scores as wrong without the model being wrong -- it ran
-    out of budget mid-answer, and the fix is ``max_tokens``. Reported so a score
-    a truncation rate explains is distinguishable from one capability explains.
+    See :func:`is_truncated_finish_reason` for what counts; only token-limit
+    stops are fixed by raising ``max_tokens``.
 
     Counted per rollout, not per sample -- one truncated draw in four is a
     different fact from four (RFC #74 C) -- and deduplicated by rollout index, so
diff --git a/tests/unit/cli/leaderboard/test_session.py b/tests/unit/cli/leaderboard/test_session.py
index 4225b878..b487311d 100644
--- a/tests/unit/cli/leaderboard/test_session.py
+++ b/tests/unit/cli/leaderboard/test_session.py
@@ -2706,18 +2706,29 @@ def test_external_completions_without_engine_remains_unknown(
         assert deployment.deployment_id is None
         assert deployment.plan is None
 
+    @pytest.mark.parametrize(
+        ("dialect_id", "model_name"),
+        [
+            ("anthropic_messages", "claude"),
+            ("google_genai", "gemini-2.5-flash"),
+        ],
+    )
     def test_native_external_dialect_requires_explicit_api_base(
-        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+        dialect_id: str,
+        model_name: str,
     ) -> None:
         config_path = self._config(
             tmp_path,
-            """
+            f"""
 models:
   m:
-    name: claude
+    name: {model_name}
     type: chat
-    dialect: anthropic_messages
-tasks: {}
+    dialect: {dialect_id}
+tasks: {{}}
 """,
         )
         monkeypatch.setenv("OPENAI_BASE_URL", "https://wrong-family.example/v1")
@@ -2725,7 +2736,7 @@ def test_native_external_dialect_requires_explicit_api_base(
 
         with pytest.raises(
             ValueError,
-            match=r"anthropic_messages.*requires an explicit api_base",
+            match=rf"{dialect_id}.*requires an explicit api_base",
         ):
             session.prepare_prelaunch()
 
@@ -3934,6 +3945,49 @@ def test_inline_grader_is_normalized_before_task_construction(
             grader.binding_id,
         }
 
+    @pytest.mark.parametrize("version_path", ["", "/v1", "/v1beta"])
+    def test_inline_google_binding_reconciles_without_provider_guessing(
+        self, tmp_path: Path, version_path: str
+    ) -> None:
+        config_path = self._config(
+            tmp_path,
+            f"""
+models:
+  candidate:
+    name: org/candidate
+tasks:
+  judged:
+    class: fake.JudgeTask
+    dataset:
+      class: fake.Dataset
+    model: candidate
+    args:
+      grader:
+        model: gemini-2.5-flash
+        dialect: google_genai
+        api_base: https://generativelanguage.googleapis.com{version_path}
+        api_key: google-secret
+""",
+        )
+        session = EvalSession(config_path)
+
+        with patch(
+            "sieval.cli.leaderboard.session.resolve_task_class",
+            return_value=self.JudgeTask,
+        ):
+            result = session.prepare_prelaunch()
+
+        grader = session._task_requirement_contexts["judged"].model_bindings["grader"]
+        assert isinstance(grader, InlineModelBinding)
+        assert grader.dialect_id == "google_genai"
+        assert "api_key" not in grader.config
+        binding_plan = result.binding_plans[grader.binding_id]
+        assert binding_plan.dialect_id == "google_genai"
+        assert (
+            result.deployment_plans[binding_plan.root_deployment_key].engine_id
+            == "unknown"
+        )
+
     def test_nested_inline_secret_is_redacted_from_stable_binding_identity(
         self, tmp_path: Path
     ) -> None:
@@ -6847,7 +6901,9 @@ def test_infer_args_e2e_yaml(self, tmp_path):
 # Deterministic mode: dialect-declared seed injection + transparent sampling
 # ===================================================================
 class TestDeterministicRequestSeedPolicy:
-    @pytest.mark.parametrize("dialect_id", ["openai_chat", "openai_completions"])
+    @pytest.mark.parametrize(
+        "dialect_id", ["openai_chat", "openai_completions", "google_genai"]
+    )
     def test_supported_dialects_receive_the_automatic_seed(self, dialect_id):
         decision = _resolve_deterministic_request_seed(
             dialect_id=dialect_id,
diff --git a/tests/unit/cli/test_validation.py b/tests/unit/cli/test_validation.py
index 270d600e..fd8191e7 100644
--- a/tests/unit/cli/test_validation.py
+++ b/tests/unit/cli/test_validation.py
@@ -475,11 +475,23 @@ def test_active_canonical_dialects_and_typed_options_are_accepted(self):
                 },
             )
         )
+        google = validate_eval_config(
+            self._config(
+                dialect="google_genai",
+                capabilities={
+                    "reasoning": {"effort": "high", "summary": "auto"},
+                    "hosted_tools": {"kinds": ["google_search"]},
+                    "top_logprobs": {"minimum": 20},
+                    "input_scoring": False,
+                },
+            )
+        )
 
         assert chat.ok, chat.errors
         assert completions.ok, completions.errors
         assert responses.ok, responses.errors
         assert anthropic.ok, anthropic.errors
+        assert google.ok, google.errors
 
     @pytest.mark.parametrize("dialect", [None, "", 7, ["openai_chat"]])
     def test_explicit_malformed_dialect_is_rejected(self, dialect):
@@ -591,6 +603,17 @@ def test_dialect_specific_option_validator_is_used(self):
             "does not support reasoning budget_tokens" in e for e in result.errors
         )
 
+    def test_google_capability_domain_is_rejected_during_static_validation(self):
+        result = validate_eval_config(
+            self._config(
+                dialect="google_genai",
+                capabilities={"top_logprobs": {"minimum": 21}},
+            )
+        )
+
+        assert not result.ok
+        assert any("at most 20 top logprobs" in error for error in result.errors)
+
     def test_legacy_type_is_not_a_second_default_dialect_resolver(self):
         result = validate_eval_config(
             self._config(
@@ -1694,9 +1717,9 @@ def test_active_anthropic_dialect_reconciles_to_its_runtime_plan(self, tmp_path)
             "    model: m\n",
             encoding="utf-8",
         )
-        content = config.read_text(encoding="utf-8")
-
-        direct = validate_eval_config(yaml.safe_load(content))
+        direct = validate_eval_config(
+            yaml.safe_load(config.read_text(encoding="utf-8"))
+        )
         dry_run = run_dry_run(config)
         checks = {check["name"]: check for check in dry_run["checks"]}
 
@@ -1709,6 +1732,92 @@ def test_active_anthropic_dialect_reconciles_to_its_runtime_plan(self, tmp_path)
             "anthropic_messages"
         )
 
+    @pytest.mark.parametrize("version_path", ["", "/v1", "/v1beta"])
+    def test_active_google_dialect_reconciles_to_its_runtime_plan(
+        self, tmp_path, version_path
+    ):
+        """Static validation and dry-run carry Google through reconciliation."""
+        from sieval.cli.validation import run_dry_run
+
+        config = tmp_path / "google-genai.yaml"
+        config.write_text(
+            "models:\n"
+            "  m:\n"
+            "    name: gemini-2.5-flash\n"
+            "    type: chat\n"
+            "    dialect: google_genai\n"
+            f"    api_base: https://generativelanguage.googleapis.com{version_path}\n"
+            "    api_key: test-key\n"
+            "datasets:\n"
+            "  d:\n"
+            "    class: sieval.datasets.aime_2024.AIME2024Dataset\n"
+            "tasks:\n"
+            "  t:\n"
+            "    class: sieval.tasks.aime_2024_0shot_gen.AIME2024ZeroShotGenTask\n"
+            "    dataset: d\n"
+            "    model: m\n",
+            encoding="utf-8",
+        )
+
+        direct = validate_eval_config(
+            yaml.safe_load(config.read_text(encoding="utf-8"))
+        )
+        dry_run = run_dry_run(config)
+        checks = {check["name"]: check for check in dry_run["checks"]}
+
+        assert direct.ok, direct.errors
+        assert dry_run["n_errors"] == 0
+        assert checks["schema"]["ok"] is True
+        assert checks["imports"]["ok"] is True
+        assert checks["capability_reconcile"]["ok"] is True
+        binding_plans = checks["capability_reconcile"]["plan"]["binding_plans"]
+        assert len(binding_plans) == 1
+        assert next(iter(binding_plans.values()))["dialect_id"] == "google_genai"
+
+    def test_google_capability_is_static_valid_but_requires_profile_evidence(
+        self, tmp_path
+    ):
+        """Deep dry-run owns model-specific Google capability admission."""
+        from sieval.cli.validation import run_dry_run
+
+        config = tmp_path / "google-genai-capability.yaml"
+        config.write_text(
+            "models:\n"
+            "  m:\n"
+            "    name: gemini-2.5-flash\n"
+            "    type: chat\n"
+            "    dialect: google_genai\n"
+            "    api_base: https://generativelanguage.googleapis.com\n"
+            "    capabilities:\n"
+            "      reasoning:\n"
+            "        summary: auto\n"
+            "datasets:\n"
+            "  d:\n"
+            "    class: sieval.datasets.aime_2024.AIME2024Dataset\n"
+            "tasks:\n"
+            "  t:\n"
+            "    class: sieval.tasks.aime_2024_0shot_gen.AIME2024ZeroShotGenTask\n"
+            "    dataset: d\n"
+            "    model: m\n",
+            encoding="utf-8",
+        )
+
+        direct = validate_eval_config(
+            yaml.safe_load(config.read_text(encoding="utf-8"))
+        )
+        dry_run = run_dry_run(config)
+        checks = {check["name"]: check for check in dry_run["checks"]}
+
+        assert direct.ok, direct.errors
+        assert checks["schema"]["ok"] is True
+        assert checks["capability_reconcile"]["ok"] is False
+        assert "model_outcome_missing" in checks["capability_reconcile"]["detail"]
+        assert (
+            "model profile provides no support outcome"
+            in checks["capability_reconcile"]["detail"]
+        )
+        assert dry_run["n_errors"] == 1
+
     def test_schema_validation_failure(self, tmp_path):
         """Config with bad schema returns schema check failure."""
         from sieval.cli.validation import run_dry_run
diff --git a/tests/unit/core/models/dialects/fixtures/google_discovery_20260928.json b/tests/unit/core/models/dialects/fixtures/google_discovery_20260928.json
new file mode 100644
index 00000000..1f0e7bc9
--- /dev/null
+++ b/tests/unit/core/models/dialects/fixtures/google_discovery_20260928.json
@@ -0,0 +1,321 @@
+{
+  "_description": "Reduced official Discovery revision 20260928: full Schema property signatures, function-parameter descriptors, and complete property names at version-sensitive request locations. Fetched once for offline tests, never at runtime.",
+  "function_parameter_fields": {
+    "v1": {
+      "parameters": {
+        "$ref": "Schema",
+        "description": "Optional. Describes the parameters to this function. Reflects the Open API 3.03 Parameter Object string Key: the name of the parameter. Parameter names are case sensitive. Schema Value: the Schema defining the type used for the parameter."
+      }
+    },
+    "v1beta": {
+      "parameters": {
+        "$ref": "Schema",
+        "description": "Optional. Describes the parameters to this function. Reflects the Open API 3.03 Parameter Object string Key: the name of the parameter. Parameter names are case sensitive. Schema Value: the Schema defining the type used for the parameter."
+      },
+      "parametersJsonSchema": {
+        "description": "Optional. Describes the parameters to the function in JSON Schema format. The schema must describe an object where the properties are the parameters to the function. For example: ``` { \"type\": \"object\", \"properties\": { \"name\": { \"type\": \"string\" }, \"age\": { \"type\": \"integer\" } }, \"additionalProperties\": false, \"required\": [\"name\", \"age\"], \"propertyOrdering\": [\"name\", \"age\"] } ``` This field is mutually exclusive with `parameters`.",
+        "type": "any"
+      }
+    }
+  },
+  "revision": "20260928",
+  "schema_properties": {
+    "anyOf": {
+      "items": {
+        "$ref": "Schema"
+      },
+      "type": "array"
+    },
+    "default": {
+      "description": "Optional. Default value of the field. Per JSON Schema, this field is intended for documentation generators and doesn't affect validation. Thus it's included here and ignored so that developers who send schemas with a `default` field don't get unknown-field errors.",
+      "type": "any"
+    },
+    "description": {
+      "type": "string"
+    },
+    "enum": {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "example": {
+      "description": "Optional. Example of the object. Will only populated when the object is the root.",
+      "type": "any"
+    },
+    "format": {
+      "type": "string"
+    },
+    "items": {
+      "$ref": "Schema"
+    },
+    "maxItems": {
+      "format": "int64",
+      "type": "string"
+    },
+    "maxLength": {
+      "format": "int64",
+      "type": "string"
+    },
+    "maxProperties": {
+      "format": "int64",
+      "type": "string"
+    },
+    "maximum": {
+      "format": "double",
+      "type": "number"
+    },
+    "minItems": {
+      "format": "int64",
+      "type": "string"
+    },
+    "minLength": {
+      "format": "int64",
+      "type": "string"
+    },
+    "minProperties": {
+      "format": "int64",
+      "type": "string"
+    },
+    "minimum": {
+      "format": "double",
+      "type": "number"
+    },
+    "nullable": {
+      "type": "boolean"
+    },
+    "pattern": {
+      "type": "string"
+    },
+    "properties": {
+      "additionalProperties": {
+        "$ref": "Schema"
+      },
+      "type": "object"
+    },
+    "propertyOrdering": {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "required": {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "title": {
+      "type": "string"
+    },
+    "type": {
+      "enum": [
+        "TYPE_UNSPECIFIED",
+        "STRING",
+        "NUMBER",
+        "INTEGER",
+        "BOOLEAN",
+        "ARRAY",
+        "OBJECT",
+        "NULL"
+      ],
+      "enumDescriptions": [
+        "Not specified, should not be used.",
+        "String type.",
+        "Number type.",
+        "Integer type.",
+        "Boolean type.",
+        "Array type.",
+        "Object type.",
+        "Null type."
+      ],
+      "type": "string"
+    }
+  },
+  "sources": {
+    "v1": "https://generativelanguage.googleapis.com/$discovery/rest?version=v1",
+    "v1beta": "https://generativelanguage.googleapis.com/$discovery/rest?version=v1beta"
+  },
+  "versioned_fields": {
+    "v1": {
+      "Blob": [
+        "data",
+        "mimeType"
+      ],
+      "FileData": [
+        "fileUri",
+        "mimeType"
+      ],
+      "FunctionDeclaration": [
+        "description",
+        "name",
+        "parameters",
+        "response"
+      ],
+      "FunctionResponse": [
+        "id",
+        "name",
+        "response"
+      ],
+      "GenerateContentRequest": [
+        "contents",
+        "generationConfig",
+        "model",
+        "safetySettings",
+        "serviceTier",
+        "store",
+        "systemInstruction",
+        "toolConfig",
+        "tools"
+      ],
+      "GenerationConfig": [
+        "_responseJsonSchema",
+        "candidateCount",
+        "enableEnhancedCivicAnswers",
+        "frequencyPenalty",
+        "imageConfig",
+        "logprobs",
+        "maxOutputTokens",
+        "mediaResolution",
+        "presencePenalty",
+        "responseFormat",
+        "responseJsonSchema",
+        "responseLogprobs",
+        "responseMimeType",
+        "responseModalities",
+        "responseSchema",
+        "seed",
+        "stopSequences",
+        "temperature",
+        "thinkingConfig",
+        "topK",
+        "topP"
+      ],
+      "Part": [
+        "codeExecutionResult",
+        "executableCode",
+        "fileData",
+        "functionCall",
+        "functionResponse",
+        "inlineData",
+        "mediaProcessing",
+        "mediaResolution",
+        "partMetadata",
+        "text",
+        "thought",
+        "thoughtSignature",
+        "toolCall",
+        "toolResponse",
+        "videoMetadata"
+      ],
+      "Tool": [
+        "codeExecution",
+        "fileSearch",
+        "functionDeclarations",
+        "googleMaps",
+        "googleSearch",
+        "googleSearchRetrieval",
+        "urlContext"
+      ]
+    },
+    "v1beta": {
+      "Blob": [
+        "data",
+        "displayName",
+        "mimeType"
+      ],
+      "FileData": [
+        "displayName",
+        "fileUri",
+        "mimeType"
+      ],
+      "FunctionDeclaration": [
+        "behavior",
+        "description",
+        "name",
+        "parameters",
+        "parametersJsonSchema",
+        "response",
+        "responseJsonSchema"
+      ],
+      "FunctionResponse": [
+        "id",
+        "name",
+        "parts",
+        "response",
+        "scheduling",
+        "willContinue"
+      ],
+      "GenerateContentRequest": [
+        "cachedContent",
+        "contents",
+        "generationConfig",
+        "labels",
+        "model",
+        "safetySettings",
+        "serviceTier",
+        "store",
+        "systemInstruction",
+        "toolConfig",
+        "tools"
+      ],
+      "GenerationConfig": [
+        "_responseJsonSchema",
+        "audioTranscriptionConfig",
+        "candidateCount",
+        "enableAffectiveDialog",
+        "enableEnhancedCivicAnswers",
+        "frequencyPenalty",
+        "imageConfig",
+        "logprobs",
+        "maxOutputTokens",
+        "mediaResolution",
+        "presencePenalty",
+        "responseFormat",
+        "responseJsonSchema",
+        "responseLogprobs",
+        "responseMimeType",
+        "responseModalities",
+        "responseSchema",
+        "seed",
+        "speechConfig",
+        "stopSequences",
+        "temperature",
+        "thinkingConfig",
+        "topK",
+        "topP",
+        "translationConfig"
+      ],
+      "Part": [
+        "audioTranscription",
+        "codeExecutionResult",
+        "executableCode",
+        "fileData",
+        "functionCall",
+        "functionResponse",
+        "inlineData",
+        "mediaProcessing",
+        "mediaResolution",
+        "partMetadata",
+        "speechMetadata",
+        "text",
+        "thought",
+        "thoughtSignature",
+        "toolCall",
+        "toolResponse",
+        "videoMetadata"
+      ],
+      "Tool": [
+        "codeExecution",
+        "computerUse",
+        "fileSearch",
+        "functionDeclarations",
+        "googleMaps",
+        "googleSearch",
+        "googleSearchRetrieval",
+        "mcpServers",
+        "urlContext"
+      ]
+    }
+  }
+}
diff --git a/tests/unit/core/models/dialects/test__google_genai_wire.py b/tests/unit/core/models/dialects/test__google_genai_wire.py
new file mode 100644
index 00000000..6ba482b7
--- /dev/null
+++ b/tests/unit/core/models/dialects/test__google_genai_wire.py
@@ -0,0 +1,451 @@
+"""Contract tests for versioned Google routes and lossless Schema conversion.
+
+AI-Generated Code - GPT-5 (OpenAI)
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+import httpx
+import pytest
+
+from sieval.core.models.dialect import DialectError
+from sieval.core.models.dialects import _google_genai_wire as wire
+from sieval.core.models.dialects._google_genai_wire import (
+    GOOGLE_WIRE_CONTRACTS,
+    inspect_function_schema,
+    lower_function_schema,
+    resolve_wire_endpoint,
+    validate_wire_body,
+)
+
+
+@pytest.fixture
+def discovery_contract() -> dict[str, Any]:
+    # This is a reduced upstream snapshot, not output from our converter.
+    # CI must remain offline and must not derive expectations from local tables.
+    path = Path(__file__).parent / "fixtures" / "google_discovery_20260928.json"
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+class TestDiscoveryContract:
+    def test_schema_whitelist_and_scalar_types_match_pinned_discovery(
+        self, discovery_contract: dict[str, Any]
+    ) -> None:
+        assert discovery_contract["revision"] == "20260928"
+        fields = discovery_contract["schema_properties"]
+        assert set(fields) == wire._SCHEMA_KEYS
+        assert {
+            value.lower()
+            for value in fields["type"]["enum"]
+            if value != "TYPE_UNSPECIFIED"
+        } == wire._SCHEMA_TYPES
+        assert {
+            name for name, spec in fields.items() if spec.get("format") == "int64"
+        } == wire._SCHEMA_COUNTS
+        assert {
+            name
+            for name, spec in fields.items()
+            if spec.get("type") == "string"
+            and spec.get("format") != "int64"
+            and name != "type"
+        } == wire._SCHEMA_STRINGS
+        assert {
+            name for name, spec in fields.items() if spec.get("type") == "number"
+        } == wire._SCHEMA_NUMBERS
+        assert {
+            name
+            for name, spec in fields.items()
+            if spec.get("type") == "array" and spec.get("items") == {"type": "string"}
+        } == wire._SCHEMA_STRING_LISTS
+
+    def test_size_limits_use_discovery_int64_strings(
+        self, discovery_contract: dict[str, Any]
+    ) -> None:
+        for key, spec in discovery_contract["schema_properties"].items():
+            if spec.get("format") != "int64":
+                continue
+            assert spec["type"] == "string"
+            type_name = (
+                "array"
+                if key.endswith("Items")
+                else "object"
+                if key.endswith("Properties")
+                else "string"
+            )
+            assert lower_function_schema({"type": type_name, key: 1}) == {
+                "type": type_name.upper(),
+                key: "1",
+            }
+            assert inspect_function_schema({"type": type_name.upper(), key: "1"}) == {
+                "type": type_name,
+                key: 1,
+            }
+
+    def test_version_differences_match_upstream_field_inventories(
+        self, discovery_contract: dict[str, Any]
+    ) -> None:
+        v1, beta = (
+            discovery_contract["versioned_fields"][version]
+            for version in ("v1", "v1beta")
+        )
+        locations = {
+            "request": "GenerateContentRequest",
+            "generationConfig": "GenerationConfig",
+            "tool": "Tool",
+            "functionDeclaration": "FunctionDeclaration",
+            "part": "Part",
+            "functionResponse": "FunctionResponse",
+            "inlineData": "Blob",
+            "fileData": "FileData",
+        }
+        assert GOOGLE_WIRE_CONTRACTS["v1"].unavailable_fields == {
+            location: frozenset(beta[shape]) - frozenset(v1[shape])
+            for location, shape in locations.items()
+        }
+        assert GOOGLE_WIRE_CONTRACTS["v1beta"].unavailable_fields == {}
+        parameters = discovery_contract["function_parameter_fields"]
+        assert set(parameters["v1"]) == {"parameters"}
+        assert set(parameters["v1beta"]) == {"parameters", "parametersJsonSchema"}
+        for version in ("v1", "v1beta"):
+            selected = GOOGLE_WIRE_CONTRACTS[version].function_schema_field
+            assert selected in parameters[version]
+
+
+class TestEndpoints:
+    @pytest.mark.parametrize(
+        ("path", "version", "root"),
+        [
+            ("", "v1beta", "/"),
+            ("/", "v1beta", "/"),
+            ("/v1", "v1", "/"),
+            ("/v1beta/", "v1beta", "/"),
+            ("/gateway/google", "v1beta", "/gateway/google/"),
+            ("/gateway/google/v1/", "v1", "/gateway/google/"),
+            ("/gateway/v2/google", "v1beta", "/gateway/v2/google/"),
+            ("/gateway/v2/google/v1", "v1", "/gateway/v2/google/"),
+        ],
+    )
+    def test_root_and_explicit_version_preserve_gateway_prefix(
+        self, path: str, version: str, root: str
+    ) -> None:
+        url = httpx.URL(f"https://example.test{path}")
+        contract, endpoint_root = resolve_wire_endpoint(url)
+        assert contract.api_version == version
+        assert endpoint_root == httpx.URL(f"https://example.test{root}")
+        assert str(url) == str(httpx.URL(f"https://example.test{path}"))
+
+    @pytest.mark.parametrize(
+        "path",
+        [
+            "/v2",
+            "/v1alpha/",
+            "/gateway/v9beta",
+            "/v1/models/gemini-2.5-flash:generateContent",
+            "/models/gemini-2.5-flash",
+            "/v1?key=secret",
+            "/v1#fragment",
+        ],
+    )
+    def test_ambiguous_endpoint_is_rejected(self, path: str) -> None:
+        with pytest.raises(ValueError, match="Google api_base"):
+            resolve_wire_endpoint(httpx.URL(f"https://example.test{path}"))
+
+
+class TestFunctionSchema:
+    @pytest.mark.parametrize(
+        ("source", "wire"),
+        [
+            ("string", "STRING"),
+            ("number", "NUMBER"),
+            ("integer", "INTEGER"),
+            ("boolean", "BOOLEAN"),
+            ("array", "ARRAY"),
+            ("object", "OBJECT"),
+            ("null", "NULL"),
+        ],
+    )
+    def test_type_enums_use_independent_golden_values(
+        self, source: str, wire: str
+    ) -> None:
+        assert lower_function_schema({"type": source}) == {"type": wire}
+        assert inspect_function_schema({"type": wire}) == {"type": source}
+
+    def test_nested_schema_preserves_constraints_and_opaque_annotations(self) -> None:
+        annotation = {"type": "not a schema", "parametersJsonSchema": {"$ref": "x"}}
+        source = {
+            "type": "object",
+            "title": "Title",
+            "description": "Description",
+            "minProperties": 0,
+            "maxProperties": 2**63 - 1,
+            "required": ["type"],
+            "propertyOrdering": ["type"],
+            "properties": {
+                "type": {
+                    "type": "array",
+                    "minItems": 0,
+                    "maxItems": 3,
+                    "items": {
+                        "type": "string",
+                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                        "nullable": True,
+                        "minLength": 0,
+                        "maxLength": 50,
+                        "pattern": "^a",
+                        "format": "enum",
+                        "enum": ["a", "ab"],
+                        "default": annotation,
+                        "example": annotation,
+                    },
+                },
+                "minimum": {"type": "number", "minimum": -1.5, "maximum": 2**53},
+            },
+        }
+        wire = {
+            "type": "OBJECT",
+            "title": "Title",
+            "description": "Description",
+            "minProperties": "0",
+            "maxProperties": "9223372036854775807",
+            "required": ["type"],
+            "propertyOrdering": ["type"],
+            "properties": {
+                "type": {
+                    "type": "ARRAY",
+                    "minItems": "0",
+                    "maxItems": "3",
+                    "items": {
+                        "type": "STRING",
+                        "anyOf": [{"type": "STRING"}, {"type": "NULL"}],
+                        "nullable": True,
+                        "minLength": "0",
+                        "maxLength": "50",
+                        "pattern": "^a",
+                        "format": "enum",
+                        "enum": ["a", "ab"],
+                        "default": annotation,
+                        "example": annotation,
+                    },
+                },
+                "minimum": {"type": "NUMBER", "minimum": -1.5, "maximum": 2**53},
+            },
+        }
+        assert lower_function_schema(source) == wire
+        assert inspect_function_schema(wire) == source
+
+    @pytest.mark.parametrize("decode", [False, True])
+    @pytest.mark.parametrize(
+        ("invalid", "message"),
+        [
+            ({"title": 1}, "requires a string"),
+            ({"nullable": 1}, "requires a boolean"),
+            ({"minimum": True}, "finite double"),
+            ({"maximum": "3"}, "finite double"),
+            ({"minimum": 2**53 + 1}, "finite double"),
+            ({"minimum": 10**400}, "finite double"),
+            ({"minimum": float("inf")}, "invalid Google v1 Schema"),
+            ({"enum": [1]}, "requires strings"),
+            ({"enum": "a"}, "requires strings"),
+            ({"enum": []}, "non-empty enum"),
+            ({"required": ["a", "a"]}, "unique strings"),
+            ({"properties": []}, "properties.*requires an object"),
+            ({"items": []}, "items.*requires an object"),
+            ({"anyOf": []}, "anyOf.*non-empty array"),
+            ({"anyOf": {}}, "anyOf.*non-empty array"),
+            ({"additionalProperties": False}, "cannot represent keyword"),
+            ({"default": object()}, "invalid Google v1 Schema"),
+            ({1: "bad JSON key"}, "invalid Google v1 Schema"),
+        ],
+    )
+    def test_invalid_node_is_rejected_in_encoder_and_independent_decoder(
+        self, decode: bool, invalid: dict[Any, Any], message: str
+    ) -> None:
+        schema = {"type": "STRING" if decode else "string", **invalid}
+        operation = inspect_function_schema if decode else lower_function_schema
+        with pytest.raises(DialectError, match=message):
+            operation(schema)
+
+    @pytest.mark.parametrize(
+        ("schema", "message"),
+        [
+            ({}, "single explicit JSON Schema type"),
+            ({"type": ["string", "null"]}, "single explicit JSON Schema type"),
+            ({"type": "STRING"}, "single explicit JSON Schema type"),
+            ({"type": "integer", "enum": ["1"]}, "only maps string enums"),
+            ({"type": "string", "maxLength": -1}, "non-negative int64"),
+            ({"type": "string", "maxLength": True}, "non-negative int64"),
+            ({"type": "string", "maxLength": "1"}, "non-negative int64"),
+            ({"type": "string", "maxLength": 2**63}, "non-negative int64"),
+        ],
+    )
+    def test_source_schema_rejects_lossy_mapping(
+        self, schema: dict[str, Any], message: str
+    ) -> None:
+        with pytest.raises(DialectError, match=message):
+            lower_function_schema(schema)
+
+    @pytest.mark.parametrize(
+        ("schema", "message"),
+        [
+            ({}, "uppercase type"),
+            ({"type": "string"}, "uppercase type"),
+            ({"type": "INTEGER", "enum": ["1"]}, "only maps string enums"),
+            ({"type": "STRING", "maxLength": 1}, "int64 string"),
+            ({"type": "STRING", "maxLength": "-1"}, "int64 string"),
+            ({"type": "STRING", "maxLength": "01"}, "int64 string"),
+            ({"type": "STRING", "maxLength": "9223372036854775808"}, "out of range"),
+        ],
+    )
+    def test_wire_schema_rejects_noncanonical_types(
+        self, schema: dict[str, Any], message: str
+    ) -> None:
+        with pytest.raises(DialectError, match=message):
+            inspect_function_schema(schema)
+
+
+class TestVersionedBody:
+    @pytest.mark.parametrize(
+        ("version", "field", "type_name"),
+        [
+            ("v1", "parameters", "STRING"),
+            ("v1beta", "parameters", "STRING"),
+            ("v1beta", "parametersJsonSchema", "string"),
+        ],
+    )
+    def test_function_parameter_root_must_describe_an_object(
+        self, version: str, field: str, type_name: str
+    ) -> None:
+        body = {"tools": [{"functionDeclarations": [{field: {"type": type_name}}]}]}
+        with pytest.raises(DialectError, match="function parameters.*object"):
+            validate_wire_body(body, GOOGLE_WIRE_CONTRACTS[version])
+
+    @pytest.mark.parametrize(
+        "schema", [{}, None, False, [], {"type": ["object", "null"]}]
+    )
+    def test_json_schema_parameter_root_is_explicit_even_in_direct_wire_check(
+        self, schema: Any
+    ) -> None:
+        body = {"tools": [{"functionDeclarations": [{"parametersJsonSchema": schema}]}]}
+        with pytest.raises(DialectError, match="function parameters.*object"):
+            validate_wire_body(body, GOOGLE_WIRE_CONTRACTS["v1beta"])
+
+    @pytest.mark.parametrize(
+        ("version", "field", "type_name"),
+        [
+            ("v1", "response", "STRING"),
+            ("v1beta", "response", "STRING"),
+            ("v1beta", "responseJsonSchema", "string"),
+        ],
+    )
+    def test_function_response_schema_is_not_subject_to_parameter_root_rule(
+        self, version: str, field: str, type_name: str
+    ) -> None:
+        body = {"tools": [{"functionDeclarations": [{field: {"type": type_name}}]}]}
+        validate_wire_body(body, GOOGLE_WIRE_CONTRACTS[version])
+
+    @pytest.mark.parametrize(
+        ("body", "field"),
+        [
+            ({"cachedContent": "cachedContents/a"}, "cachedContent"),
+            ({"labels": {"tag": "value"}}, "labels"),
+            ({"generationConfig": {"speechConfig": {}}}, "speechConfig"),
+            ({"tools": [{"computerUse": {}}]}, "computerUse"),
+            (
+                {
+                    "tools": [
+                        {
+                            "functionDeclarations": [
+                                {"parametersJsonSchema": {"type": "object"}}
+                            ]
+                        }
+                    ]
+                },
+                "parametersJsonSchema",
+            ),
+            (
+                {"tools": [{"functionDeclarations": [{"responseJsonSchema": {}}]}]},
+                "responseJsonSchema",
+            ),
+            (
+                {"tools": [{"functionDeclarations": [{"behavior": "BLOCKING"}]}]},
+                "behavior",
+            ),
+            (
+                {"contents": [{"parts": [{"audioTranscription": {}}]}]},
+                "audioTranscription",
+            ),
+            ({"contents": [{"parts": [{"functionResponse": {"parts": []}}]}]}, "parts"),
+            (
+                {"contents": [{"parts": [{"inlineData": {"displayName": "a"}}]}]},
+                "displayName",
+            ),
+            (
+                {"contents": [{"parts": [{"fileData": {"displayName": "a"}}]}]},
+                "displayName",
+            ),
+            (
+                {"systemInstruction": {"parts": [{"speechMetadata": {}}]}},
+                "speechMetadata",
+            ),
+        ],
+    )
+    def test_beta_only_fields_are_checked_at_their_schema_location(
+        self, body: dict[str, Any], field: str
+    ) -> None:
+        with pytest.raises(DialectError, match=f"{field}.*unavailable.*v1"):
+            validate_wire_body(body, GOOGLE_WIRE_CONTRACTS["v1"])
+        validate_wire_body(body, GOOGLE_WIRE_CONTRACTS["v1beta"])
+
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    def test_user_json_is_not_recursively_interpreted_as_protocol_fields(
+        self, version: str
+    ) -> None:
+        user_json = {"cachedContent": "text", "parametersJsonSchema": {"behavior": 1}}
+        body = {
+            "generationConfig": {"responseJsonSchema": user_json},
+            "contents": [
+                {"parts": [{"functionResponse": {"name": "f", "response": user_json}}]},
+                {"parts": [{"functionCall": {"name": "f", "args": user_json}}]},
+            ],
+            "tools": [
+                {
+                    "functionDeclarations": [
+                        {
+                            "parameters": {
+                                "type": "OBJECT",
+                                "properties": {"cachedContent": {"type": "STRING"}},
+                                "default": user_json,
+                            }
+                        }
+                    ]
+                }
+            ],
+        }
+        # Beta supports parameters too, even though SiEval emits parametersJsonSchema.
+        validate_wire_body(body, GOOGLE_WIRE_CONTRACTS[version])
+
+    @pytest.mark.parametrize("field", ["parameters", "response"])
+    def test_beta_schema_representations_are_mutually_exclusive(
+        self, field: str
+    ) -> None:
+        body = {
+            "tools": [
+                {
+                    "functionDeclarations": [
+                        {field: {"type": "OBJECT"}, f"{field}JsonSchema": {}}
+                    ]
+                }
+            ]
+        }
+        with pytest.raises(DialectError, match="mutually exclusive"):
+            validate_wire_body(body, GOOGLE_WIRE_CONTRACTS["v1beta"])
+
+    def test_non_schema_values_do_not_crash_version_specific_check(self) -> None:
+        # General shape validation belongs to the dialect's input/feature verifiers.
+        body = {
+            "tools": [None, {"functionDeclarations": [None]}],
+            "contents": [None, {"parts": "not a parts array"}, {"parts": [None]}],
+        }
+        validate_wire_body(body, GOOGLE_WIRE_CONTRACTS["v1"])
diff --git a/tests/unit/core/models/dialects/test_google_genai.py b/tests/unit/core/models/dialects/test_google_genai.py
new file mode 100644
index 00000000..04dda8d5
--- /dev/null
+++ b/tests/unit/core/models/dialects/test_google_genai.py
@@ -0,0 +1,7067 @@
+"""Tests for the native Google Gemini ``generateContent`` dialect.
+
+AI-Generated Code - GPT-5.6 (OpenAI)
+"""
+
+import json
+import re
+from collections.abc import AsyncIterator, Callable, Mapping
+from types import SimpleNamespace
+from typing import Any, Literal, cast
+
+import httpx
+import pytest
+
+from sieval.core.models.capabilities import (
+    CAPABILITY_KEYS,
+    DialectCapabilityStatus,
+    HostedToolsOptions,
+    ReasoningOptions,
+    Supported,
+    TopLogprobsOptions,
+    Unsupported,
+)
+from sieval.core.models.connection_factory import AsyncHTTPJSONConnection
+from sieval.core.models.dialect import (
+    DialectError,
+    OutputContractError,
+    PreparedRequest,
+    Rejected,
+    RequestAudit,
+    RequestAuditError,
+    active_request_leaves,
+)
+from sieval.core.models.dialect_registry import DIALECT_SPECS
+from sieval.core.models.dialects import google_genai
+from sieval.core.models.dialects._google_genai_wire import GOOGLE_WIRE_CONTRACTS
+from sieval.core.models.dialects.google_genai import (
+    CAPABILITY_DECISIONS,
+    GoogleGenAIDialect,
+)
+from sieval.core.models.ir import (
+    ChatInput,
+    ChatMessage,
+    ChatRole,
+    CompletionInput,
+    DialectOptions,
+    HostedToolSpec,
+    ImagePart,
+    OpaqueContinuation,
+    ReasoningParams,
+    Request,
+    SamplingParams,
+    SchedulingParams,
+    ScoringParams,
+    SessionParams,
+    StructuredOutputParams,
+    TextPart,
+    ToolCallPart,
+    ToolParams,
+    ToolResultPart,
+)
+
+
+def _chat(*messages: ChatMessage) -> ChatInput:
+    return ChatInput(messages or (ChatMessage("user", (TextPart("Hello"),)),))
+
+
+def _request(**changes: object) -> Request:
+    values: dict[str, object] = {"input": _chat()}
+    values.update(changes)
+    return Request(**cast(Any, values))
+
+
+def _response(
+    parts: list[dict[str, object]] | None = None,
+    *,
+    finish_reason: object = "STOP",
+    usage: object | None = None,
+    model_version: object = "gemini-2.5-flash",
+    candidate_extra: Mapping[str, object] | None = None,
+) -> dict[str, object]:
+    candidate: dict[str, object] = {
+        "index": 0,
+        "content": {
+            "role": "model",
+            "parts": parts if parts is not None else [{"text": "Hi"}],
+        },
+        "finishReason": finish_reason,
+    }
+    if candidate_extra:
+        candidate.update(candidate_extra)
+    return {
+        "candidates": [candidate],
+        "usageMetadata": usage
+        if usage is not None
+        else {
+            "promptTokenCount": 4,
+            "candidatesTokenCount": 2,
+            "totalTokenCount": 7,
+            "thoughtsTokenCount": 1,
+            "cachedContentTokenCount": 2,
+        },
+        "modelVersion": model_version,
+    }
+
+
+def _connection(
+    handler: Callable[[httpx.Request], httpx.Response],
+    *,
+    base_url: str = "https://generativelanguage.googleapis.com/",
+    credential: str | None = "google-secret",
+) -> AsyncHTTPJSONConnection:
+    return AsyncHTTPJSONConnection(
+        httpx.AsyncClient(base_url=base_url, transport=httpx.MockTransport(handler)),
+        credential,
+    )
+
+
+async def _run(
+    handler: Callable[[httpx.Request], httpx.Response],
+    request: Request | None = None,
+    *,
+    model: str = "gemini-2.5-flash",
+    base_url: str = "https://generativelanguage.googleapis.com/",
+    credential: str | None = "google-secret",
+):
+    connection = _connection(handler, base_url=base_url, credential=credential)
+    try:
+        return await GoogleGenAIDialect(connection, model).arun(request or _request())
+    finally:
+        await connection.aclose()
+
+
+def _sse(*chunks: Mapping[str, object]) -> bytes:
+    lines: list[str] = []
+    for chunk in chunks:
+        payload = json.dumps(chunk, separators=(",", ":"))
+        split_at = payload.find(",", len(payload) // 2)
+        if split_at < 0:
+            lines.extend((f"data: {payload}", ""))
+        else:
+            lines.extend(
+                (
+                    f"data: {payload[: split_at + 1]}",
+                    f"data:{payload[split_at + 1 :]}",
+                    "",
+                )
+            )
+    return "\n".join(lines).encode()
+
+
+def _no_io(_: httpx.Request) -> httpx.Response:
+    raise AssertionError("request rejection must happen before HTTP I/O")
+
+
+class TestCapabilities:
+    def test_decision_row_and_registry_are_complete(self) -> None:
+        assert set(CAPABILITY_DECISIONS) == set(CAPABILITY_KEYS)
+        assert isinstance(CAPABILITY_DECISIONS["input_scoring"], Unsupported)
+        for key in (
+            "sampled_logprobs",
+            "top_logprobs",
+            "reasoning",
+            "function_tools",
+            "hosted_tools",
+            "structured_output",
+            "opaque_continuation",
+            "multimodal_input",
+        ):
+            assert isinstance(CAPABILITY_DECISIONS[key], Supported)
+
+        spec = DIALECT_SPECS["google_genai"]
+        assert spec.implementation_status.value == "active"
+        assert spec.request_seed_support.value == "supported"
+        assert spec.capability_outcomes["reasoning"] is (
+            DialectCapabilityStatus.SUPPORTED
+        )
+
+    @pytest.mark.parametrize(
+        ("key", "options", "message"),
+        [
+            ("top_logprobs", TopLogprobsOptions(21), "20"),
+            (
+                "reasoning",
+                ReasoningOptions(summary="detailed"),
+                "reasoning summary 'none' or 'auto'",
+            ),
+            ("reasoning", ReasoningOptions(effort="xhigh"), "thinking level"),
+            (
+                "hosted_tools",
+                HostedToolsOptions(("web_search",)),
+                "google_search",
+            ),
+        ],
+    )
+    def test_capability_domains_are_provider_validated(
+        self, key: str, options: object, message: str
+    ) -> None:
+        decision = cast(Supported, CAPABILITY_DECISIONS[cast(Any, key)])
+        with pytest.raises(ValueError, match=message):
+            decision.binding.validate_config(cast(Any, options))
+
+    @pytest.mark.parametrize("summary", ["none", "auto"])
+    def test_reasoning_config_accepts_both_summary_modes(self, summary: str) -> None:
+        decision = cast(Supported, CAPABILITY_DECISIONS["reasoning"])
+        decision.binding.validate_config(ReasoningOptions(summary=summary))
+
+
+class TestRequestLowering:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("base_url", "model", "expected_path"),
+        [
+            (
+                "https://generativelanguage.googleapis.com/",
+                "gemini-2.5-flash",
+                "/v1beta/models/gemini-2.5-flash:generateContent",
+            ),
+            (
+                "https://generativelanguage.googleapis.com/v1beta/",
+                "models/gemini-2.5-flash",
+                "/v1beta/models/gemini-2.5-flash:generateContent",
+            ),
+            (
+                "https://generativelanguage.googleapis.com/v1",
+                "gemini-2.5-flash",
+                "/v1/models/gemini-2.5-flash:generateContent",
+            ),
+            (
+                "https://gateway.example/google/v1/",
+                "models/gemini-2.5-flash",
+                "/google/v1/models/gemini-2.5-flash:generateContent",
+            ),
+            (
+                "https://gateway.example/v2/google/v1/",
+                "gemini-2.5-flash",
+                "/v2/google/v1/models/gemini-2.5-flash:generateContent",
+            ),
+        ],
+    )
+    async def test_native_request_uses_final_url_header_and_wire_body(
+        self, base_url: str, model: str, expected_path: str
+    ) -> None:
+        seen: dict[str, object] = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["request"] = request
+            seen["body"] = json.loads(request.content)
+            return httpx.Response(200, json=_response())
+
+        req = _request(
+            input=_chat(
+                ChatMessage("system", (TextPart("Be concise"),)),
+                ChatMessage("user", (TextPart("Hello"),)),
+            ),
+            sampling=SamplingParams(
+                temperature=0.2,
+                top_p=0.9,
+                top_k=40,
+                max_tokens=64,
+                stop=("END",),
+                seed=7,
+                frequency_penalty=0.1,
+                presence_penalty=-0.2,
+            ),
+        )
+        result = await _run(handler, req, model=model, base_url=base_url)
+
+        request = cast(httpx.Request, seen["request"])
+        assert request.url.path == expected_path
+        assert request.headers["x-goog-api-key"] == "google-secret"
+        assert seen["body"] == {
+            "contents": [{"role": "user", "parts": [{"text": "Hello"}]}],
+            "systemInstruction": {"parts": [{"text": "Be concise"}]},
+            "generationConfig": {
+                "temperature": 0.2,
+                "topP": 0.9,
+                "topK": 40,
+                "maxOutputTokens": 64,
+                "stopSequences": ["END"],
+                "seed": 7,
+                "frequencyPenalty": 0.1,
+                "presencePenalty": -0.2,
+            },
+        }
+        assert result.texts == ("Hi",)
+        assert result.finish_reasons == ("STOP",)
+        assert result.request_params == {
+            "method": "POST",
+            "path": expected_path,
+            "body": {
+                "generationConfig": cast(dict[str, object], seen["body"])[
+                    "generationConfig"
+                ]
+            },
+        }
+        assert "google-secret" not in json.dumps(result.request_params)
+
+    @pytest.mark.anyio
+    async def test_missing_credential_does_not_emit_auth_header(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert "x-goog-api-key" not in request.headers
+            return httpx.Response(200, json=_response())
+
+        await _run(handler, credential=None)
+
+    @pytest.mark.anyio
+    async def test_prepared_context_is_detached_from_mutable_request_inputs(
+        self,
+    ) -> None:
+        function_specs: list[Mapping[str, object]] = [
+            {"name": "lookup", "description": "Lookup a value"}
+        ]
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["tools"] == [
+                {
+                    "functionDeclarations": [
+                        {"name": "lookup", "description": "Lookup a value"}
+                    ]
+                }
+            ]
+            return httpx.Response(
+                200,
+                json=_response(
+                    parts=[
+                        {
+                            "functionCall": {
+                                "id": "call_1",
+                                "name": "lookup",
+                                "args": {},
+                            }
+                        }
+                    ]
+                ),
+            )
+
+        connection = _connection(handler)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(
+                tools=ToolParams(functions=cast(Any, function_specs)),
+            )
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            audit.finish(prepared)
+
+            function_specs.clear()
+
+            result = await dialect.execute(prepared)
+        finally:
+            await connection.aclose()
+
+        assert result.tool_calls is not None
+        assert result.tool_calls[0].name == "lookup"
+
+    @pytest.mark.anyio
+    async def test_multimodal_parts_preserve_order(self) -> None:
+        seen: dict[str, object] = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content)
+            return httpx.Response(200, json=_response())
+
+        req = _request(
+            input=_chat(
+                ChatMessage(
+                    "user",
+                    (
+                        TextPart("before"),
+                        ImagePart(data="aGVsbG8=", media_type="image/png"),
+                        TextPart("after"),
+                        ImagePart(url="gs://bucket/image.jpg", media_type="image/jpeg"),
+                    ),
+                )
+            )
+        )
+        await _run(handler, req)
+
+        body = cast(dict[str, Any], seen["body"])
+        assert body["contents"][0]["parts"] == [
+            {"text": "before"},
+            {"inlineData": {"data": "aGVsbG8=", "mimeType": "image/png"}},
+            {"text": "after"},
+            {
+                "fileData": {
+                    "fileUri": "gs://bucket/image.jpg",
+                    "mimeType": "image/jpeg",
+                }
+            },
+        ]
+
+    @pytest.mark.anyio
+    async def test_url_image_cannot_bypass_image_only_media_types(self) -> None:
+        req = _request(
+            input=_chat(
+                ChatMessage(
+                    "user",
+                    (
+                        ImagePart(
+                            url="gs://bucket/document.pdf", media_type="application/pdf"
+                        ),
+                    ),
+                )
+            )
+        )
+
+        with pytest.raises(DialectError, match="unsupported Google image media type"):
+            await _run(_no_io, req)
+
+    @pytest.mark.anyio
+    async def test_function_result_recovers_name_from_prior_call(self) -> None:
+        seen: dict[str, object] = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content)
+            return httpx.Response(200, json=_response())
+
+        req = _request(
+            input=_chat(
+                ChatMessage(
+                    "assistant",
+                    (ToolCallPart("call_1", "weather", {"city": "Paris"}),),
+                ),
+                ChatMessage(
+                    "tool",
+                    (ToolResultPart("call_1", {"temperature": 20}),),
+                ),
+                ChatMessage("user", (TextPart("Continue"),)),
+            )
+        )
+        await _run(handler, req)
+
+        assert cast(dict[str, Any], seen["body"])["contents"] == [
+            {
+                "role": "model",
+                "parts": [
+                    {
+                        "functionCall": {
+                            "id": "call_1",
+                            "name": "weather",
+                            "args": {"city": "Paris"},
+                        }
+                    }
+                ],
+            },
+            {
+                "role": "user",
+                "parts": [
+                    {
+                        "functionResponse": {
+                            "id": "call_1",
+                            "name": "weather",
+                            "response": {"temperature": 20},
+                        }
+                    }
+                ],
+            },
+            {"role": "user", "parts": [{"text": "Continue"}]},
+        ]
+
+    @pytest.mark.anyio
+    async def test_unanswered_function_call_is_rejected_before_io(self) -> None:
+        req = _request(
+            input=_chat(
+                ChatMessage(
+                    "assistant",
+                    (
+                        ToolCallPart("call_1", "first", {}),
+                        ToolCallPart("call_2", "second", {}),
+                    ),
+                ),
+                ChatMessage("tool", (ToolResultPart("call_1", {"ok": True}),)),
+            )
+        )
+
+        with pytest.raises(DialectError, match="unanswered.*call_2"):
+            await _run(_no_io, req, model="gemini-3-pro-preview")
+
+    @pytest.mark.anyio
+    async def test_function_responses_must_follow_their_call_turn(self) -> None:
+        req = _request(
+            input=_chat(
+                ChatMessage(
+                    "assistant",
+                    (ToolCallPart("call_a", "first", {}),),
+                ),
+                ChatMessage("user", (TextPart("intervening text"),)),
+                ChatMessage(
+                    "assistant",
+                    (ToolCallPart("call_b", "second", {}),),
+                ),
+                ChatMessage(
+                    "tool",
+                    (
+                        ToolResultPart("call_a", {"ok": True}),
+                        ToolResultPart("call_b", {"ok": True}),
+                    ),
+                ),
+            )
+        )
+
+        with pytest.raises(DialectError, match="immediately follow.*call_a"):
+            await _run(_no_io, req)
+
+    @pytest.mark.anyio
+    async def test_each_function_call_turn_may_be_answered_in_order(self) -> None:
+        seen: dict[str, object] = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["contents"] = json.loads(request.content)["contents"]
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                input=_chat(
+                    ChatMessage(
+                        "assistant",
+                        (ToolCallPart("call_a", "first", {}),),
+                    ),
+                    ChatMessage("tool", (ToolResultPart("call_a", {"a": True}),)),
+                    ChatMessage(
+                        "assistant",
+                        (ToolCallPart("call_b", "second", {}),),
+                    ),
+                    ChatMessage("tool", (ToolResultPart("call_b", {"b": True}),)),
+                )
+            ),
+        )
+
+        contents = cast(list[dict[str, Any]], seen["contents"])
+        assert [content["role"] for content in contents] == [
+            "model",
+            "user",
+            "model",
+            "user",
+        ]
+        assert contents[1]["parts"][0]["functionResponse"]["id"] == "call_a"
+        assert contents[3]["parts"][0]["functionResponse"]["id"] == "call_b"
+
+    @pytest.mark.anyio
+    async def test_error_tool_result_is_explicit(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["contents"][1]["parts"][0]["functionResponse"]["response"] == {
+                "error": "failed"
+            }
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                input=_chat(
+                    ChatMessage("assistant", (ToolCallPart("c", "tool", {}),)),
+                    ChatMessage("tool", (ToolResultPart("c", "failed", True),)),
+                )
+            ),
+        )
+
+    @pytest.mark.anyio
+    async def test_function_and_hosted_tools_lower_with_observable_invocations(
+        self,
+    ) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["tools"] == [
+                {
+                    "functionDeclarations": [
+                        {
+                            "name": "weather",
+                            "description": "Get weather",
+                            "parametersJsonSchema": {
+                                "type": "object",
+                                "properties": {"city": {"type": "string"}},
+                            },
+                        }
+                    ]
+                },
+                {"googleSearch": {}},
+            ]
+            assert body["toolConfig"] == {
+                "functionCallingConfig": {
+                    "mode": "ANY",
+                    "allowedFunctionNames": ["weather"],
+                },
+                "includeServerSideToolInvocations": True,
+            }
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                tools=ToolParams(
+                    functions=(
+                        {
+                            "type": "function",
+                            "function": {
+                                "name": "weather",
+                                "description": "Get weather",
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {"city": {"type": "string"}},
+                                },
+                            },
+                        },
+                    ),
+                    choice={"type": "function", "name": "weather"},
+                    hosted=(HostedToolSpec("google_search"),),
+                )
+            ),
+            model="gemini-3.8-flash",
+        )
+
+    @pytest.mark.anyio
+    async def test_hosted_tools_map_explicit_auto_to_validated(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["toolConfig"] == {
+                "functionCallingConfig": {"mode": "VALIDATED"},
+                "includeServerSideToolInvocations": True,
+            }
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                tools=ToolParams(
+                    functions=({"name": "weather", "description": "Get weather"},),
+                    choice="auto",
+                    hosted=(HostedToolSpec("google_search"),),
+                )
+            ),
+            model="gemini-3.8-flash",
+        )
+
+    @pytest.mark.anyio
+    async def test_hosted_tool_configs_follow_google_discovery_schema(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["tools"] == [
+                {
+                    "googleSearch": {
+                        "timeRangeFilter": {
+                            "startTime": "2026-01-01T00:00:00Z",
+                            "endTime": "2026-02-01T00:00:00Z",
+                        },
+                        "searchTypes": {
+                            "webSearch": {},
+                            "imageSearch": {},
+                        },
+                    }
+                },
+                {"urlContext": {}},
+            ]
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                tools=ToolParams(
+                    hosted=(
+                        HostedToolSpec(
+                            "google_search",
+                            {
+                                "timeRangeFilter": {
+                                    "startTime": "2026-01-01T00:00:00Z",
+                                    "endTime": "2026-02-01T00:00:00Z",
+                                },
+                                "searchTypes": {
+                                    "webSearch": {},
+                                    "imageSearch": {},
+                                },
+                            },
+                        ),
+                        HostedToolSpec("url_context"),
+                    )
+                )
+            ),
+        )
+
+    @pytest.mark.anyio
+    async def test_hosted_tool_time_range_accepts_equal_rfc3339_instants(self) -> None:
+        interval = {
+            "startTime": "2026-01-01T05:30:00.123456789+05:30",
+            "endTime": "2026-01-01T00:00:00.123456789Z",
+        }
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["tools"] == [{"googleSearch": {"timeRangeFilter": interval}}]
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                tools=ToolParams(
+                    hosted=(
+                        HostedToolSpec("google_search", {"timeRangeFilter": interval}),
+                    )
+                )
+            ),
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("tool", "message"),
+        [
+            (
+                HostedToolSpec("url_context", {"unexpected": True}),
+                "url_context config must be an empty object",
+            ),
+            (
+                HostedToolSpec("google_search", {"whatever": 123}),
+                "unsupported field.*whatever",
+            ),
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {"timeRangeFilter": {"startTime": "2026-01-01T00:00:00Z"}},
+                ),
+                "requires startTime and endTime together",
+            ),
+            (
+                HostedToolSpec("google_search", {"timeRangeFilter": []}),
+                "timeRangeFilter must be an object",
+            ),
+            (
+                HostedToolSpec("google_search", {"timeRangeFilter": {"future": True}}),
+                "timeRangeFilter has unsupported field.*future",
+            ),
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {"timeRangeFilter": {"startTime": "", "endTime": "end"}},
+                ),
+                "startTime must be a non-empty timestamp string",
+            ),
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {
+                        "timeRangeFilter": {
+                            "startTime": "banana",
+                            "endTime": "apple",
+                        }
+                    },
+                ),
+                "startTime must be an RFC3339 timestamp",
+            ),
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {
+                        "timeRangeFilter": {
+                            "startTime": "2026-01-01T00:00:00",
+                            "endTime": "2026-01-02T00:00:00Z",
+                        }
+                    },
+                ),
+                "startTime must be an RFC3339 timestamp",
+            ),
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {
+                        "timeRangeFilter": {
+                            "startTime": "2026-12-31T00:00:00Z",
+                            "endTime": "2026-01-01T00:00:00Z",
+                        }
+                    },
+                ),
+                "startTime must not be after endTime",
+            ),
+            (
+                HostedToolSpec("google_search", {"searchTypes": []}),
+                "searchTypes must be an object",
+            ),
+            (
+                HostedToolSpec("google_search", {"searchTypes": {"futureSearch": {}}}),
+                "searchTypes has unsupported field.*futureSearch",
+            ),
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {"searchTypes": {"webSearch": {"unexpected": True}}},
+                ),
+                "webSearch must be an empty object",
+            ),
+        ],
+    )
+    async def test_invalid_hosted_tool_configs_fail_before_io(
+        self, tool: HostedToolSpec, message: str
+    ) -> None:
+        with pytest.raises(RequestAuditError, match=message):
+            await _run(
+                _no_io,
+                _request(tools=ToolParams(hosted=(tool,))),
+            )
+
+    @pytest.mark.anyio
+    async def test_function_only_explicit_auto_remains_auto(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["toolConfig"] == {
+                "functionCallingConfig": {"mode": "AUTO"}
+            }
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                tools=ToolParams(
+                    functions=({"name": "weather", "description": "Get weather"},),
+                    choice="auto",
+                )
+            ),
+        )
+
+    @pytest.mark.anyio
+    async def test_safety_settings_are_audited_root_options(self) -> None:
+        settings = [
+            {
+                "category": "HARM_CATEGORY_HATE_SPEECH",
+                "threshold": "BLOCK_ONLY_HIGH",
+            }
+        ]
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["safetySettings"] == settings
+            return httpx.Response(200, json=_response())
+
+        result = await _run(
+            handler,
+            _request(
+                dialect_options=DialectOptions(
+                    "google_genai", {"safetySettings": settings}
+                )
+            ),
+        )
+        assert result.request_params is not None
+        assert result.request_params["body"] == {"safetySettings": settings}
+
+    @pytest.mark.anyio
+    async def test_provider_specific_root_controls_remain_audited_options(
+        self,
+    ) -> None:
+        options = {
+            "cachedContent": "cachedContents/example",
+            "serviceTier": "PRIORITY",
+            "store": False,
+        }
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert {key: body[key] for key in options} == options
+            return httpx.Response(200, json=_response())
+
+        result = await _run(
+            handler,
+            _request(dialect_options=DialectOptions("google_genai", options)),
+        )
+
+        assert result.request_params is not None
+        assert result.request_params["body"] == options
+
+
+class TestAPIVersionContracts:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_versions_have_explicit_operations_and_final_wire_schemas(
+        self, version: str, stream: bool
+    ) -> None:
+        # Golden bodies come from the two Discovery schemas (20260928), not
+        # the dialect's version table or schema converter.
+        source_schema = {
+            "type": "object",
+            "properties": {
+                "city": {"type": "string", "minLength": 1},
+                "units": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                "days": {
+                    "type": "array",
+                    "items": {"type": "integer", "minimum": 1, "maximum": 7},
+                    "maxItems": 3,
+                },
+            },
+            "required": ["city"],
+        }
+        v1_schema = {
+            "type": "OBJECT",
+            "properties": {
+                "city": {"type": "STRING", "minLength": "1"},
+                "units": {"type": "STRING", "enum": ["celsius", "fahrenheit"]},
+                "days": {
+                    "type": "ARRAY",
+                    "items": {"type": "INTEGER", "minimum": 1, "maximum": 7},
+                    "maxItems": "3",
+                },
+            },
+            "required": ["city"],
+        }
+        declaration = {
+            "name": "weather",
+            "description": "Get weather",
+            "parameters" if version == "v1" else "parametersJsonSchema": (
+                v1_schema if version == "v1" else source_schema
+            ),
+        }
+        method = "streamGenerateContent" if stream else "generateContent"
+        path = f"/gateway/{version}/models/gemini-2.5-flash:{method}"
+        seen: list[httpx.Request] = []
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen.append(request)
+            assert request.url.path == path
+            assert dict(request.url.params) == ({"alt": "sse"} if stream else {})
+            assert json.loads(request.content) == {
+                "contents": [{"role": "user", "parts": [{"text": "Hello"}]}],
+                "tools": [{"functionDeclarations": [declaration]}],
+            }
+            payload = _response(
+                usage={
+                    "promptTokenCount": 4,
+                    "candidatesTokenCount": 2,
+                    "totalTokenCount": 6,
+                }
+            )
+            if stream:
+                return httpx.Response(200, content=_sse(payload))
+            return httpx.Response(200, json=payload)
+
+        connection = _connection(
+            handler, base_url=f"https://example.test/gateway/{version}"
+        )
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(
+                scheduling=SchedulingParams(stream=stream),
+                tools=ToolParams(
+                    functions=(
+                        {
+                            "name": "weather",
+                            "description": "Get weather",
+                            "parameters": source_schema,
+                        },
+                    )
+                ),
+            )
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            assert prepared.operation == (
+                f"{version}/models/gemini-2.5-flash:{method}"
+                + ("?alt=sse" if stream else "")
+            )
+            audit.finish(prepared)
+            result = await dialect.execute(prepared)
+            assert len(seen) == 1
+            assert result.texts == ("Hi",)
+            assert result.request_params is not None
+            assert result.request_params["path"] == seen[0].url.path
+            assert result.request_params["body"] == {
+                "tools": [{"functionDeclarations": [declaration]}]
+            }
+            assert result.usage is not None
+            assert result.usage.cached_tokens is None
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_cross_version_operation_is_rejected_by_audit_and_execute(
+        self, version: str, stream: bool
+    ) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{version}")
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(scheduling=SchedulingParams(stream=stream))
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            other = "v1beta" if version == "v1" else "v1"
+            method = "streamGenerateContent" if stream else "generateContent"
+            mutated = PreparedRequest(
+                f"{other}/models/gemini-2.5-flash:{method}"
+                + ("?alt=sse" if stream else ""),
+                prepared.body,
+                prepared.context,
+            )
+            with pytest.raises(RequestAuditError, match="operation .* does not match"):
+                audit.finish(mutated)
+            with pytest.raises(DialectError, match="wrong prepared operation"):
+                await dialect.execute(mutated)
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    async def test_final_http_version_drift_is_rejected(
+        self, version: str, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{version}")
+        build_request = connection.client.build_request
+        other = "v1beta" if version == "v1" else "v1"
+
+        def drifted_request(*args: Any, **kwargs: Any) -> httpx.Request:
+            result = build_request(*args, **kwargs)
+            result.url = result.url.copy_with(
+                path=f"/{other}/models/gemini-2.5-flash:generateContent"
+            )
+            return result
+
+        monkeypatch.setattr(connection.client, "build_request", drifted_request)
+        try:
+            with pytest.raises(DialectError, match="final Google request URL"):
+                await GoogleGenAIDialect(connection, "gemini-2.5-flash").arun(
+                    _request()
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    async def test_cross_version_function_shape_fails_independent_verifier(
+        self, version: str
+    ) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{version}")
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(
+                tools=ToolParams(
+                    functions=(
+                        {
+                            "name": "f",
+                            "description": "Function f",
+                            "parameters": {"type": "object"},
+                        },
+                    )
+                )
+            )
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, Any], prepared.thaw_body())
+            declaration = body["tools"][0]["functionDeclarations"][0]
+            if version == "v1beta":
+                declaration.pop("parametersJsonSchema")
+                declaration["parameters"] = {"type": "OBJECT"}
+            else:
+                declaration.pop("parameters")
+                declaration["parametersJsonSchema"] = {"type": "object"}
+            mutated = PreparedRequest(prepared.operation, body, prepared.context)
+            with pytest.raises(RequestAuditError, match="function tools changed"):
+                audit.finish(mutated)
+            with pytest.raises(DialectError, match="function|parametersJsonSchema"):
+                await dialect.execute(mutated)
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "schema",
+        [
+            {"type": "object", "additionalProperties": False},
+            {"type": "object", "$defs": {"x": {"type": "string"}}},
+            {"type": "object", "properties": {"x": {"$ref": "#/$defs/x"}}},
+            {"type": "object", "properties": {"x": {"type": ["string", "null"]}}},
+            {
+                "type": "object",
+                "properties": {"x": {"type": "integer", "enum": [1, 2]}},
+            },
+            {
+                "type": "object",
+                "properties": {"x": {"type": "integer", "minimum": 2**53 + 1}},
+            },
+        ],
+    )
+    async def test_v1_rejects_unrepresentable_json_schema_before_io(
+        self, schema: dict[str, Any]
+    ) -> None:
+        req = _request(
+            tools=ToolParams(
+                functions=(
+                    {
+                        "name": "f",
+                        "description": "Function f",
+                        "parameters": schema,
+                    },
+                )
+            )
+        )
+        connection = _connection(_no_io, base_url="https://example.test/v1")
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            with pytest.raises(RequestAuditError, match="tools.functions.*v1"):
+                audit.raise_rejections()
+            with pytest.raises(DialectError, match="v1"):
+                dialect.prepare(req, RequestAudit(active_request_leaves(req)))
+        finally:
+            await connection.aclose()
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert (
+                json.loads(request.content)["tools"][0]["functionDeclarations"][0][
+                    "parametersJsonSchema"
+                ]
+                == schema
+            )
+            return httpx.Response(200, json=_response())
+
+        # These remain JSON values on v1beta; v1 must not silently strip them.
+        await _run(handler, req, base_url="https://example.test/v1beta")
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("key", ["cachedContent", "labels"])
+    async def test_beta_only_root_option_is_rejected_on_v1(self, key: str) -> None:
+        req = _request(dialect_options=DialectOptions("google_genai", {key: "value"}))
+        with pytest.raises(RequestAuditError, match=f"{key}.*v1"):
+            await _run(_no_io, req, base_url="https://example.test/v1")
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version_path", ["", "/v1", "/v1beta"])
+    @pytest.mark.parametrize("wrapped", [False, True])
+    @pytest.mark.parametrize(
+        "schema",
+        [
+            {"type": "string"},
+            {"type": "integer"},
+            {"type": "array", "items": {"type": "string"}},
+            None,
+            False,
+            [],
+            {},
+            {"properties": {"x": {"type": "string"}}},
+            {"type": ["object", "null"]},
+            {"$ref": "#/$defs/P", "$defs": {"P": {"type": "object"}}},
+        ],
+    )
+    async def test_function_parameters_must_describe_an_object(
+        self, version_path: str, wrapped: bool, schema: object
+    ) -> None:
+        source: dict[str, Any] = {
+            "name": "f",
+            "description": "Function f",
+            "parameters": schema,
+        }
+        if wrapped:
+            source = {"type": "function", "function": source}
+        req = _request(tools=ToolParams(functions=(source,)))
+        connection = _connection(_no_io, base_url=f"https://example.test{version_path}")
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            with pytest.raises(RequestAuditError, match="tools.functions.*object"):
+                audit.raise_rejections()
+            # Bypassing validate_request must not turn an invalid schema into wire.
+            with pytest.raises(DialectError, match="function parameters.*object"):
+                dialect.prepare(req, RequestAudit(active_request_leaves(req)))
+            with pytest.raises(RequestAuditError, match="tools.functions.*object"):
+                await dialect.arun(req)
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    @pytest.mark.parametrize(
+        "schema", [None, {"type": "object"}, {"type": "object", "properties": {}}]
+    )
+    async def test_no_argument_functions_keep_valid_wire_shapes(
+        self, version: str, schema: dict[str, Any] | None
+    ) -> None:
+        source: dict[str, Any] = {"name": "f", "description": "Function f"}
+        expected: dict[str, Any] = dict(source)
+        if schema is not None:
+            source["parameters"] = schema
+            field = "parameters" if version == "v1" else "parametersJsonSchema"
+            expected[field] = {
+                **schema,
+                "type": "OBJECT" if version == "v1" else "object",
+            }
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["tools"] == [
+                {"functionDeclarations": [expected]}
+            ]
+            return httpx.Response(200, json=_response())
+
+        response = await _run(
+            handler,
+            _request(tools=ToolParams(functions=(source,))),
+            base_url=f"https://example.test/{version}",
+        )
+        assert response.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    async def test_final_http_function_parameter_root_is_checked(
+        self, version: str, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{version}")
+        build_request = connection.client.build_request
+
+        def drifted_request(*args: Any, **kwargs: Any) -> httpx.Request:
+            request = build_request(*args, **kwargs)
+            body = json.loads(request.content)
+            field = "parameters" if version == "v1" else "parametersJsonSchema"
+            body["tools"][0]["functionDeclarations"][0][field] = {
+                "type": "STRING" if version == "v1" else "string"
+            }
+            return httpx.Request(request.method, request.url, json=body)
+
+        monkeypatch.setattr(connection.client, "build_request", drifted_request)
+        # Observe the final-wire validator specifically, not the later
+        # source-vs-wire equality check that would also catch this mutation.
+        monkeypatch.setattr(
+            google_genai._FunctionsVerifier, "verify", lambda *args: None
+        )
+        try:
+            req = _request(
+                tools=ToolParams(
+                    functions=(
+                        {
+                            "name": "f",
+                            "description": "Function f",
+                            "parameters": {"type": "object"},
+                        },
+                    )
+                )
+            )
+            with pytest.raises(DialectError, match="function parameters.*object"):
+                await GoogleGenAIDialect(connection, "gemini-2.5-flash").arun(req)
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.parametrize(
+        "body",
+        [
+            {"tools": None},
+            {"tools": [{"functionDeclarations": "not a list"}]},
+            {"tools": [{"functionDeclarations": [1]}]},
+            {"tools": [{"functionDeclarations": [{"default": object()}]}]},
+            {"tools": [{"functionDeclarations": [], "googleSearch": {}}]},
+            {"tools": [{"functionDeclarations": []}, {"functionDeclarations": []}]},
+            {
+                "tools": [
+                    {
+                        "functionDeclarations": [
+                            {
+                                "name": "f",
+                                "description": "Function f",
+                                "parameters": {"type": "object"},
+                            }
+                        ]
+                    }
+                ]
+            },
+        ],
+    )
+    def test_functions_verifier_rejects_invalid_direct_inputs(
+        self, body: dict[str, Any]
+    ) -> None:
+        verifier = google_genai._FunctionsVerifier(
+            (
+                {
+                    "name": "f",
+                    "description": "Function f",
+                    "parameters": {"type": "object"},
+                },
+            ),
+            GOOGLE_WIRE_CONTRACTS["v1"],
+        )
+        assert verifier.verify(body) == "function tools changed"
+
+    def test_functions_verifier_rejects_invalid_source_and_unrequested_group(
+        self,
+    ) -> None:
+        with pytest.raises(TypeError, match="function declarations must be objects"):
+            google_genai._FunctionsVerifier(
+                (cast(Any, []),), GOOGLE_WIRE_CONTRACTS["v1"]
+            )
+        verifier = google_genai._FunctionsVerifier((), GOOGLE_WIRE_CONTRACTS["v1"])
+        assert verifier.verify({}) is None
+        assert verifier.verify({"tools": [{"functionDeclarations": []}]}) == (
+            "function tools changed"
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("version", "extra"),
+        [
+            ("v1", "both_schema_fields"),
+            ("v1beta", "both_schema_fields"),
+            ("v1", "beta_root_field"),
+            ("v1", "changed_constraint"),
+            ("v1beta", "changed_constraint"),
+        ],
+    )
+    async def test_final_serialized_function_schema_is_checked(
+        self, version: str, extra: str, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{version}")
+        build_request = connection.client.build_request
+
+        def drifted_request(*args: Any, **kwargs: Any) -> httpx.Request:
+            result = build_request(*args, **kwargs)
+            body = json.loads(result.content)
+            declaration = body["tools"][0]["functionDeclarations"][0]
+            if extra == "both_schema_fields":
+                declaration["parameters"] = {"type": "OBJECT"}
+                declaration["parametersJsonSchema"] = {"type": "object"}
+            elif extra == "beta_root_field":
+                body["cachedContent"] = "cachedContents/unrequested"
+            else:
+                key = "parameters" if version == "v1" else "parametersJsonSchema"
+                declaration[key]["properties"]["value"]["minimum"] = 3
+            return httpx.Request(result.method, result.url, json=body)
+
+        monkeypatch.setattr(connection.client, "build_request", drifted_request)
+        req = _request(
+            tools=ToolParams(
+                functions=(
+                    {
+                        "name": "f",
+                        "description": "Function f",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {"value": {"type": "integer", "minimum": 2}},
+                        },
+                    },
+                )
+            )
+        )
+        try:
+            with pytest.raises(
+                DialectError,
+                match="unavailable|mutually exclusive|function tools changed",
+            ):
+                await GoogleGenAIDialect(connection, "gemini-2.5-flash").arun(req)
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_function_schema_encoder_cannot_supply_its_own_audit_oracle(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(_no_io, base_url="https://example.test/v1")
+        encode = google_genai.lower_function_schema
+
+        def drop_required(raw: object) -> dict[str, Any]:
+            result = encode(raw)
+            result.pop("required", None)
+            return result
+
+        monkeypatch.setattr(google_genai, "lower_function_schema", drop_required)
+        req = _request(
+            tools=ToolParams(
+                functions=(
+                    {
+                        "name": "f",
+                        "description": "Function f",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {"x": {"type": "string"}},
+                            "required": ["x"],
+                        },
+                    },
+                )
+            )
+        )
+        try:
+            with pytest.raises(RequestAuditError, match="function tools changed"):
+                await GoogleGenAIDialect(connection, "gemini-2.5-flash").arun(req)
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    async def test_schema_annotations_and_field_named_properties_are_not_rewritten(
+        self, version: str
+    ) -> None:
+        annotation = {"type": "object", "cachedContent": "value", "minItems": 7}
+        schema = {
+            "type": "object",
+            "properties": {"parametersJsonSchema": {"type": "string"}},
+            "default": annotation,
+            "example": annotation,
+        }
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            key = "parameters" if version == "v1" else "parametersJsonSchema"
+            actual = body["tools"][0]["functionDeclarations"][0][key]
+            assert actual["example"] == annotation
+            assert actual["default"] == annotation
+            assert set(actual["properties"]) == {"parametersJsonSchema"}
+            assert actual["properties"]["parametersJsonSchema"] == {
+                "type": "STRING" if version == "v1" else "string"
+            }
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                tools=ToolParams(
+                    functions=(
+                        {
+                            "name": "f",
+                            "description": "Function f",
+                            "parameters": schema,
+                        },
+                    )
+                )
+            ),
+            base_url=f"https://example.test/{version}",
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_shared_response_features_work_on_each_version(
+        self, version: str, stream: bool
+    ) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert request.url.path.startswith(f"/{version}/models/")
+            assert body["generationConfig"] == {
+                "thinkingConfig": {"thinkingBudget": 128, "includeThoughts": True},
+                "responseMimeType": "application/json",
+                "responseJsonSchema": {"type": "object"},
+            }
+            assert body["tools"] == [{"googleSearch": {}}, {"urlContext": {}}]
+            payload = _response(parts=[{"text": '{"ok":true}'}])
+            return (
+                httpx.Response(200, content=_sse(payload))
+                if stream
+                else httpx.Response(200, json=payload)
+            )
+
+        result = await _run(
+            handler,
+            _request(
+                reasoning=ReasoningParams(budget_tokens=128, summary="auto"),
+                structured_output=StructuredOutputParams(
+                    format="json_schema", schema={"type": "object"}
+                ),
+                tools=ToolParams(
+                    hosted=(
+                        HostedToolSpec("google_search"),
+                        HostedToolSpec("url_context"),
+                    )
+                ),
+                scheduling=SchedulingParams(stream=stream),
+            ),
+            base_url=f"https://example.test/{version}",
+        )
+        assert result.structured_output is not None
+        assert result.structured_output.value == {"ok": True}
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("path", ["v2", "v1alpha", "v1bet", "v1/models/f"])
+    async def test_unknown_or_resource_endpoint_is_rejected(self, path: str) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{path}")
+        try:
+            with pytest.raises(ValueError, match="Google.*api_base"):
+                GoogleGenAIDialect(connection, "gemini-2.5-flash")
+        finally:
+            await connection.aclose()
+
+
+class TestPreIORejections:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("req", "message"),
+        [
+            (_request(input=CompletionInput("prompt")), "ChatInput"),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage("user", (TextPart("first"),)),
+                        ChatMessage("system", (TextPart("late"),)),
+                    )
+                ),
+                "must precede",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage("developer", (TextPart("higher priority"),)),
+                        ChatMessage("user", (TextPart("question"),)),
+                    )
+                ),
+                "developer message authority",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage("user", (TextPart("complete this"),)),
+                        ChatMessage("assistant", (TextPart("partial"),)),
+                    )
+                ),
+                "assistant-prefill",
+            ),
+            (
+                _request(
+                    input=_chat(ChatMessage("system", (TextPart("instructions"),)))
+                ),
+                "end with a user or tool-result turn",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage(
+                            "user",
+                            (
+                                ImagePart(
+                                    data="x", media_type="image/png", detail="high"
+                                ),
+                            ),
+                        )
+                    )
+                ),
+                "detail",
+            ),
+            (
+                _request(
+                    input=_chat(ChatMessage("tool", (ToolResultPart("missing", {}),)))
+                ),
+                "no prior call",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "one", "description": "First function"},),
+                        choice={"type": "function", "name": "two"},
+                    )
+                ),
+                "undeclared",
+            ),
+            (
+                _request(
+                    structured_output=StructuredOutputParams(schema={"type": "object"})
+                ),
+                "requires format",
+            ),
+            (
+                _request(
+                    dialect_options=DialectOptions(
+                        "google_genai", {"generationConfig": {"temperature": 2}}
+                    )
+                ),
+                "provider-neutral",
+            ),
+            (
+                _request(sampling=SamplingParams(stop=("1", "2", "3", "4", "5", "6"))),
+                "five",
+            ),
+        ],
+    )
+    async def test_invalid_shapes_fail_before_io(
+        self, req: Request, message: str
+    ) -> None:
+        with pytest.raises((DialectError, RequestAuditError), match=message):
+            await _run(_no_io, req)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "sampling",
+        [
+            SamplingParams(temperature=-0.1),
+            SamplingParams(temperature=2.1),
+            SamplingParams(top_p=1.1),
+            SamplingParams(top_k=0),
+            SamplingParams(max_tokens=0),
+        ],
+    )
+    async def test_provider_sampling_domains_fail_before_io(
+        self, sampling: SamplingParams
+    ) -> None:
+        with pytest.raises(RequestAuditError):
+            await _run(_no_io, _request(sampling=sampling))
+
+    @pytest.mark.anyio
+    async def test_gemini_3_rejects_multiple_candidates_before_io(self) -> None:
+        with pytest.raises(RequestAuditError, match="candidateCount greater than 1"):
+            await _run(
+                _no_io,
+                _request(sampling=SamplingParams(n=2)),
+                model="gemini-3-pro-preview",
+            )
+
+    @pytest.mark.anyio
+    async def test_gemini_25_allows_multiple_candidates(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["generationConfig"] == {
+                "candidateCount": 2
+            }
+            payload = _response()
+            payload["candidates"] = [
+                {
+                    "index": index,
+                    "content": {"role": "model", "parts": [{"text": text}]},
+                    "finishReason": "STOP",
+                }
+                for index, text in enumerate(("first", "second"))
+            ]
+            return httpx.Response(200, json=payload)
+
+        result = await _run(
+            handler,
+            _request(sampling=SamplingParams(n=2)),
+            model="gemini-2.5-flash",
+        )
+
+        assert result.texts == ("first", "second")
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "req",
+        [
+            _request(
+                sampling=SamplingParams(n=2),
+                scoring=ScoringParams(sampled_logprobs=True),
+            ),
+            _request(
+                sampling=SamplingParams(n=2),
+                tools=ToolParams(
+                    functions=({"name": "f", "description": "Function f"},)
+                ),
+            ),
+            _request(
+                sampling=SamplingParams(n=2),
+                tools=ToolParams(hosted=(HostedToolSpec("google_search"),)),
+            ),
+            _request(
+                sampling=SamplingParams(n=2),
+                structured_output=StructuredOutputParams(format="json_object"),
+            ),
+        ],
+    )
+    async def test_multiple_candidates_reject_singular_channels_before_io(
+        self, req: Request
+    ) -> None:
+        with pytest.raises(ValueError, match="singular response channels"):
+            await _run(_no_io, req)
+
+
+class TestToolContextCirculation:
+    @staticmethod
+    def _tools(kind: str = "google_search") -> ToolParams:
+        return ToolParams(
+            functions=({"name": "weather", "description": "Get weather"},),
+            hosted=(HostedToolSpec(kind),),
+        )
+
+    @staticmethod
+    def _parts() -> list[dict[str, Any]]:
+        return [
+            {
+                "toolCall": {
+                    "id": "search_1",
+                    "toolType": "GOOGLE_SEARCH_WEB",
+                    "args": {"queries": ["weather"]},
+                },
+                "thoughtSignature": "server-call-signature",
+            },
+            {
+                "toolResponse": {
+                    "id": "search_1",
+                    "toolType": "GOOGLE_SEARCH_WEB",
+                    "response": {"found": True},
+                },
+                "thoughtSignature": "server-response-signature",
+            },
+            {
+                "functionCall": {"id": "weather_1", "name": "weather", "args": {}},
+                "thoughtSignature": "function-signature",
+            },
+        ]
+
+    @classmethod
+    def _replay_request(
+        cls, parts: list[dict[str, Any]], *, hosted: bool = True
+    ) -> Request:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {"role": "user", "parts": [{"text": "Get the weather"}]},
+                    {"role": "model", "parts": parts},
+                ],
+            }
+        )
+        return _request(
+            input=_chat(
+                ChatMessage("tool", (ToolResultPart("weather_1", {"sunny": True}),))
+            ),
+            tools=cls._tools() if hosted else ToolParams(),
+            session=SessionParams(
+                opaque_continuation=OpaqueContinuation("google_genai", opaque)
+            ),
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "model",
+        [
+            "gemini-1.5-pro",
+            "gemini-2.0-flash",
+            "gemini-2.5-pro",
+            "gemini-2.5-flash",
+            "models/gemini-2.5-flash-lite",
+        ],
+    )
+    @pytest.mark.parametrize("kind", ["google_search", "url_context"])
+    async def test_older_gemini_rejects_mixed_tools_before_io(
+        self, model: str, kind: str
+    ) -> None:
+        with pytest.raises(RequestAuditError, match="does not support combining"):
+            await _run(_no_io, _request(tools=self._tools(kind)), model=model)
+
+    @pytest.mark.anyio
+    async def test_mixed_tool_rejection_accounts_for_both_active_leaves(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(tools=self._tools())
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, google_genai._LegacyPlan())
+
+            for path in ("tools.functions", "tools.hosted"):
+                decision = audit.decisions.get(path)
+                assert isinstance(decision, Rejected)
+                assert "does not support combining" in decision.reason
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_direct_prepare_rejects_unsupported_mixed_tools(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(tools=self._tools())
+            with pytest.raises(DialectError, match="does not support combining"):
+                dialect.prepare(req, RequestAudit(active_request_leaves(req)))
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("kind", ["google_search", "url_context"])
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    async def test_gemini_3_mixed_tools_reach_the_actual_wire(
+        self, kind: str, version: str
+    ) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert len(body["tools"]) == 2
+            assert "functionDeclarations" in body["tools"][0]
+            assert body["tools"][1] == {
+                "googleSearch" if kind == "google_search" else "urlContext": {}
+            }
+            assert body["toolConfig"]["includeServerSideToolInvocations"] is True
+            return httpx.Response(200, json=_response())
+
+        result = await _run(
+            handler,
+            _request(tools=self._tools(kind)),
+            model="models/gemini-3.8-flash",
+            base_url=f"https://example.test/{version}",
+        )
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("kind", ["functions", "google_search", "url_context"])
+    async def test_gemini_25_single_tool_family_is_still_accepted(
+        self, kind: str
+    ) -> None:
+        tools = (
+            ToolParams(functions=self._tools().functions)
+            if kind == "functions"
+            else ToolParams(hosted=(HostedToolSpec(kind),))
+        )
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert len(body["tools"]) == 1
+            if kind == "functions":
+                assert "functionDeclarations" in body["tools"][0]
+            else:
+                assert body["tools"][0] == {
+                    "googleSearch" if kind == "google_search" else "urlContext": {}
+                }
+            return httpx.Response(200, json=_response())
+
+        assert (await _run(handler, _request(tools=tools))).texts == ("Hi",)
+
+    @pytest.mark.anyio
+    async def test_unknown_alias_does_not_inherit_an_older_gemini_constraint(
+        self,
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(200, json=_response()),
+            _request(tools=self._tools()),
+            model="provider-model-alias",
+        )
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("stream", [False, True])
+    @pytest.mark.parametrize("part_index", [0, 1])
+    @pytest.mark.parametrize("signature", ["absent", None])
+    async def test_gemini_3_server_parts_require_their_own_signature(
+        self, stream: bool, part_index: int, signature: str | None
+    ) -> None:
+        parts = self._parts()
+        if signature == "absent":
+            parts[part_index].pop("thoughtSignature")
+        else:
+            parts[part_index]["thoughtSignature"] = signature
+        payload = _response(parts)
+
+        def handler(_: httpx.Request) -> httpx.Response:
+            return (
+                httpx.Response(200, content=_sse(payload))
+                if stream
+                else httpx.Response(200, json=payload)
+            )
+
+        with pytest.raises(
+            OutputContractError, match=r"tool(Call|Response).*thoughtSignature"
+        ):
+            await _run(
+                handler,
+                _request(
+                    tools=self._tools(), scheduling=SchedulingParams(stream=stream)
+                ),
+                model="gemini-3.8-flash",
+            )
+
+    @pytest.mark.anyio
+    async def test_gemini_25_unsigned_server_parts_remain_accepted(self) -> None:
+        parts = self._parts()[:2]
+        for part in parts:
+            part.pop("thoughtSignature")
+        result = await _run(
+            lambda _: httpx.Response(200, json=_response(parts + [{"text": "Sunny"}])),
+            _request(tools=ToolParams(hosted=self._tools().hosted)),
+        )
+        assert result.server_tool_uses is not None
+        assert result.server_tool_uses[0].result == {"found": True}
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("invocations", [False, True])
+    async def test_response_signature_requirement_uses_the_final_wire_flag(
+        self, invocations: bool, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        parts = self._parts()[:2]
+        for part in parts:
+            part.pop("thoughtSignature")
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["toolConfig"]["includeServerSideToolInvocations"] is invocations
+            return httpx.Response(200, json=_response(parts + [{"text": "Sunny"}]))
+
+        connection = _connection(handler)
+        build_request = connection.client.build_request
+
+        def final_request(*args: Any, **kwargs: Any) -> httpx.Request:
+            request = build_request(*args, **kwargs)
+            body = json.loads(request.content)
+            body["toolConfig"]["includeServerSideToolInvocations"] = invocations
+            return httpx.Request(request.method, request.url, json=body)
+
+        monkeypatch.setattr(connection.client, "build_request", final_request)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-3.8-flash")
+            req = _request(tools=ToolParams(hosted=self._tools().hosted))
+            if invocations:
+                with pytest.raises(
+                    OutputContractError, match="toolCall.*thoughtSignature"
+                ):
+                    await dialect.arun(req)
+            else:
+                # Direct execution observes the serialized request, not the
+                # original hosted-tools leaf or prepare-time flag value.
+                result = await dialect.arun(req)
+                assert result.texts == ("Sunny",)
+                assert result.request_params is not None
+                assert result.request_params["body"] == {
+                    "tools": [{"googleSearch": {}}],
+                    "toolConfig": {"includeServerSideToolInvocations": False},
+                }
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.parametrize(
+        "body",
+        [
+            {},
+            {"contents": "wrong"},
+            {"contents": [None]},
+            {"contents": [{"parts": None}]},
+            {"contents": [{"parts": "wrong"}]},
+            {"contents": [{"parts": [None]}]},
+        ],
+    )
+    def test_server_signature_check_leaves_structural_errors_to_shape_validation(
+        self, body: dict[str, Any]
+    ) -> None:
+        google_genai._validate_server_tool_history_signatures(body, "gemini-3.8-flash")
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_signed_server_tool_history_roundtrips_without_rewriting_parts(
+        self, stream: bool
+    ) -> None:
+        parts = self._parts()
+        seen: list[dict[str, Any]] = []
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen.append(json.loads(request.content))
+            payload = _response(parts if len(seen) == 1 else [{"text": "Sunny"}])
+            return (
+                httpx.Response(200, content=_sse(payload))
+                if stream
+                else httpx.Response(200, json=payload)
+            )
+
+        connection = _connection(handler)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-3.8-flash")
+            first = await dialect.arun(
+                _request(
+                    tools=self._tools(), scheduling=SchedulingParams(stream=stream)
+                )
+            )
+            assert first.reasoning is not None and first.reasoning[0] is not None
+            opaque = first.reasoning[0].opaque_roundtrip
+            assert opaque is not None
+            assert json.loads(opaque)["contents"][-1]["parts"] == parts
+            second = await dialect.arun(
+                _request(
+                    input=_chat(
+                        ChatMessage(
+                            "tool", (ToolResultPart("weather_1", {"sunny": True}),)
+                        )
+                    ),
+                    tools=self._tools(),
+                    scheduling=SchedulingParams(stream=stream),
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    ),
+                )
+            )
+        finally:
+            await connection.aclose()
+
+        assert second.texts == ("Sunny",)
+        assert seen[1]["contents"][1]["parts"] == parts
+        assert (
+            seen[1]["contents"][-1]["parts"][0]["functionResponse"]["id"] == "weather_1"
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("part_index", [0, 1])
+    @pytest.mark.parametrize("hosted", [False, True])
+    async def test_unsigned_server_history_is_rejected_even_if_tools_are_omitted(
+        self, part_index: int, hosted: bool
+    ) -> None:
+        parts = self._parts()
+        parts[part_index].pop("thoughtSignature")
+        with pytest.raises(
+            DialectError, match=r"tool(Call|Response).*thoughtSignature"
+        ):
+            await _run(
+                _no_io,
+                self._replay_request(parts, hosted=hosted),
+                model="gemini-3.8-flash",
+            )
+
+    @pytest.mark.anyio
+    async def test_direct_prepare_checks_server_history_signatures(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            parts = self._parts()
+            parts[0].pop("thoughtSignature")
+            req = self._replay_request(parts)
+            dialect = GoogleGenAIDialect(connection, "gemini-3.8-flash")
+            with pytest.raises(DialectError, match="toolCall.*thoughtSignature"):
+                dialect.prepare(req, RequestAudit(active_request_leaves(req)))
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("part_index", [0, 1])
+    async def test_final_http_server_signature_loss_is_rejected(
+        self, part_index: int, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(_no_io)
+        build_request = connection.client.build_request
+
+        def drifted_request(*args: Any, **kwargs: Any) -> httpx.Request:
+            request = build_request(*args, **kwargs)
+            body = json.loads(request.content)
+            body["contents"][1]["parts"][part_index].pop("thoughtSignature")
+            return httpx.Request(request.method, request.url, json=body)
+
+        monkeypatch.setattr(connection.client, "build_request", drifted_request)
+        try:
+            with pytest.raises(
+                DialectError, match=r"tool(Call|Response).*thoughtSignature"
+            ):
+                await GoogleGenAIDialect(connection, "gemini-3.8-flash").arun(
+                    self._replay_request(self._parts())
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("version", ["v1", "v1beta"])
+    async def test_final_http_unsupported_tool_combination_is_rejected(
+        self, version: str, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(_no_io, base_url=f"https://example.test/{version}")
+        build_request = connection.client.build_request
+
+        def drifted_request(*args: Any, **kwargs: Any) -> httpx.Request:
+            request = build_request(*args, **kwargs)
+            body = json.loads(request.content)
+            body["tools"].append({"googleSearch": {}})
+            body["toolConfig"] = {"includeServerSideToolInvocations": True}
+            return httpx.Request(request.method, request.url, json=body)
+
+        monkeypatch.setattr(connection.client, "build_request", drifted_request)
+        try:
+            with pytest.raises(DialectError, match="does not support combining"):
+                await GoogleGenAIDialect(connection, "gemini-2.5-flash").arun(
+                    _request(tools=ToolParams(functions=self._tools().functions))
+                )
+        finally:
+            await connection.aclose()
+
+
+class TestModelSpecificRequestConstraints:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("model", "effort", "message"),
+        [
+            ("gemini-2.5-pro", "high", "does not support thinkingLevel"),
+            ("gemini-2.5-flash", "low", "does not support thinkingLevel"),
+            ("gemini-3-pro-preview", "minimal", "supports.*high, low"),
+            ("gemini-3-pro-preview", "medium", "supports.*high, low"),
+            ("gemini-3.1-pro-preview", "minimal", "supports.*low, medium"),
+            ("gemini-3.1-flash-lite-image", "low", "supports.*high, minimal"),
+            ("gemini-3.1-flash-lite-image", "medium", "supports.*high, minimal"),
+            ("gemini-3.8-flash", "minimal", "supports.*low, medium"),
+        ],
+    )
+    async def test_unsupported_thinking_levels_fail_before_io(
+        self, model: str, effort: str, message: str
+    ) -> None:
+        with pytest.raises(RequestAuditError, match=message):
+            await _run(
+                _no_io,
+                _request(reasoning=ReasoningParams(effort=effort)),
+                model=model,
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("model", "effort"),
+        [
+            ("gemini-3.6-flash", "minimal"),
+            ("gemini-3.5-flash-lite", "minimal"),
+            ("gemini-3-pro-preview", "low"),
+            ("gemini-3-pro-preview", "high"),
+            ("gemini-3.1-pro-preview", "low"),
+            ("gemini-3.1-flash-lite-image", "high"),
+            ("gemini-3.8-flash", "medium"),
+        ],
+    )
+    async def test_documented_thinking_levels_reach_the_wire(
+        self, model: str, effort: str
+    ) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            thinking = json.loads(request.content)["generationConfig"]["thinkingConfig"]
+            assert thinking == {"thinkingLevel": effort.upper()}
+            return httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {"text": "thought", "thought": True},
+                        {"text": "answer"},
+                    ]
+                ),
+            )
+
+        await _run(
+            handler,
+            _request(reasoning=ReasoningParams(effort=effort)),
+            model=model,
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("model", "budget"),
+        [
+            ("gemini-2.5-pro", 127),
+            ("gemini-2.5-pro", 32769),
+            ("gemini-2.5-flash", 24577),
+            ("gemini-2.5-flash-lite", 511),
+            ("gemini-2.5-flash-lite", 24577),
+        ],
+    )
+    async def test_out_of_range_thinking_budgets_fail_before_io(
+        self, model: str, budget: int
+    ) -> None:
+        with pytest.raises(RequestAuditError, match="budget_tokens must be between"):
+            await _run(
+                _no_io,
+                _request(reasoning=ReasoningParams(budget_tokens=budget)),
+                model=model,
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("model", "budget"),
+        [
+            ("gemini-2.5-pro", 128),
+            ("gemini-2.5-pro", 32768),
+            ("gemini-2.5-flash", 1),
+            ("gemini-2.5-flash", 24576),
+            ("gemini-2.5-flash-lite", 512),
+            ("gemini-2.5-flash-lite", 24576),
+        ],
+    )
+    async def test_documented_thinking_budget_boundaries_reach_the_wire(
+        self, model: str, budget: int
+    ) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            thinking = json.loads(request.content)["generationConfig"]["thinkingConfig"]
+            assert thinking == {"thinkingBudget": budget}
+            return httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {"text": "thought", "thought": True},
+                        {"text": "answer"},
+                    ]
+                ),
+            )
+
+        await _run(
+            handler,
+            _request(reasoning=ReasoningParams(budget_tokens=budget)),
+            model=model,
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "sampling",
+        [
+            SamplingParams(temperature=0.2),
+            SamplingParams(top_p=0.8),
+            SamplingParams(top_k=8),
+        ],
+    )
+    async def test_gemini_3_rejects_deprecated_sampling_controls(
+        self, sampling: SamplingParams
+    ) -> None:
+        with pytest.raises(RequestAuditError, match="guidance says to omit"):
+            await _run(
+                _no_io,
+                _request(sampling=sampling),
+                model="gemini-3.5-flash",
+            )
+
+
+class TestReasoningAndStructuredOutput:
+    @pytest.mark.anyio
+    async def test_visible_thoughts_and_full_history_round_trip(self) -> None:
+        first_body: dict[str, Any] = {}
+
+        def first_handler(request: httpx.Request) -> httpx.Response:
+            first_body.update(json.loads(request.content))
+            return httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "text": "analysis",
+                            "thought": True,
+                            "thoughtSignature": "sig_1",
+                        },
+                        {"text": "answer"},
+                    ]
+                ),
+            )
+
+        first = await _run(
+            first_handler,
+            _request(reasoning=ReasoningParams(effort="high", summary="auto")),
+            model="gemini-3.5-flash",
+        )
+        assert first.reasoning is not None
+        assert first.reasoning[0] is not None
+        assert first.reasoning[0].text == "analysis"
+        opaque = cast(str, first.reasoning[0].opaque_roundtrip)
+
+        def second_handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["contents"][:2] == [
+                {"role": "user", "parts": [{"text": "Hello"}]},
+                {
+                    "role": "model",
+                    "parts": [
+                        {
+                            "text": "analysis",
+                            "thought": True,
+                            "thoughtSignature": "sig_1",
+                        },
+                        {"text": "answer"},
+                    ],
+                },
+            ]
+            assert body["contents"][2] == {
+                "role": "user",
+                "parts": [{"text": "next"}],
+            }
+            return httpx.Response(
+                200,
+                json=_response([{"text": "next answer", "thoughtSignature": "sig_2"}]),
+            )
+
+        second = await _run(
+            second_handler,
+            _request(
+                input=_chat(ChatMessage("user", (TextPart("next"),))),
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                ),
+            ),
+            model="gemini-3.5-flash",
+        )
+        assert second.reasoning is not None
+        assert second.reasoning[0] is not None
+        assert second.reasoning[0].opaque_roundtrip
+
+    @pytest.mark.anyio
+    async def test_opaque_history_preserves_system_instruction(self) -> None:
+        first = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "text": "analysis",
+                            "thought": True,
+                            "thoughtSignature": "sig_1",
+                        },
+                        {"text": "answer"},
+                    ]
+                ),
+            ),
+            _request(
+                input=_chat(
+                    ChatMessage("system", (TextPart("Always answer as JSON"),)),
+                    ChatMessage("user", (TextPart("first"),)),
+                )
+            ),
+        )
+        assert first.reasoning is not None and first.reasoning[0] is not None
+        opaque = cast(str, first.reasoning[0].opaque_roundtrip)
+        envelope = json.loads(opaque)
+        assert envelope["systemInstruction"] == {
+            "parts": [{"text": "Always answer as JSON"}]
+        }
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["systemInstruction"] == envelope["systemInstruction"]
+            return httpx.Response(
+                200,
+                json=_response([{"text": "next", "thoughtSignature": "sig_2"}]),
+            )
+
+        await _run(
+            handler,
+            _request(
+                input=_chat(ChatMessage("user", (TextPart("next"),))),
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                ),
+            ),
+        )
+
+    @pytest.mark.anyio
+    async def test_opaque_history_rejects_conflicting_system_instruction(self) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "systemInstruction": {"parts": [{"text": "original"}]},
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [{"text": "answer", "thoughtSignature": "signature"}],
+                    }
+                ],
+            }
+        )
+        req = _request(
+            input=_chat(
+                ChatMessage("system", (TextPart("replacement"),)),
+                ChatMessage("user", (TextPart("next"),)),
+            ),
+            session=SessionParams(
+                opaque_continuation=OpaqueContinuation("google_genai", opaque)
+            ),
+        )
+
+        with pytest.raises(DialectError, match="systemInstruction conflicts"):
+            await _run(_no_io, req)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("server_parts", "message"),
+        [
+            (
+                [
+                    {
+                        "toolResponse": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "response": {"ok": True},
+                        }
+                    }
+                ],
+                "toolResponse.*has no prior toolCall",
+            ),
+            (
+                [
+                    {
+                        "toolCall": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "args": {},
+                        }
+                    },
+                    {
+                        "toolCall": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "args": {},
+                        }
+                    },
+                ],
+                "duplicate Google server tool call",
+            ),
+            (
+                [
+                    {
+                        "toolCall": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "args": {},
+                        }
+                    },
+                    {
+                        "toolResponse": {
+                            "id": "server_1",
+                            "toolType": "URL_CONTEXT",
+                            "response": {"ok": True},
+                        }
+                    },
+                ],
+                "toolResponse type changed",
+            ),
+            (
+                [
+                    {
+                        "toolCall": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "args": {},
+                        }
+                    },
+                    {
+                        "toolResponse": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "response": {"ok": True},
+                        }
+                    },
+                    {
+                        "toolResponse": {
+                            "id": "server_1",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "response": {"ok": True},
+                        }
+                    },
+                ],
+                "duplicate Google server tool result",
+            ),
+        ],
+    )
+    async def test_opaque_server_tool_history_rejects_invalid_call_state_before_io(
+        self, server_parts: list[dict[str, object]], message: str
+    ) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "text": "history",
+                                "thoughtSignature": "signature",
+                            },
+                            *server_parts,
+                        ],
+                    }
+                ],
+            }
+        )
+
+        with pytest.raises(DialectError, match=message):
+            await _run(
+                _no_io,
+                _request(
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    )
+                ),
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "server_parts",
+        [
+            [
+                {
+                    "toolCall": {
+                        "id": "server_1",
+                        "toolType": "GOOGLE_SEARCH_WEB",
+                        "args": {"q": "weather"},
+                    },
+                    "thoughtSignature": "signature",
+                }
+            ],
+            [
+                {
+                    "toolCall": {
+                        "id": "server_1",
+                        "toolType": "GOOGLE_SEARCH_WEB",
+                        "args": {"q": "weather"},
+                    },
+                    "thoughtSignature": "signature",
+                },
+                {
+                    "toolResponse": {
+                        "id": "server_1",
+                        "toolType": "GOOGLE_SEARCH_WEB",
+                        "response": {"ok": True},
+                    }
+                },
+            ],
+        ],
+    )
+    async def test_opaque_server_tool_history_accepts_open_or_answered_call(
+        self, server_parts: list[dict[str, object]]
+    ) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [{"role": "model", "parts": server_parts}],
+            }
+        )
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["contents"][0]["parts"] == server_parts
+            return httpx.Response(200, json=_response())
+
+        result = await _run(
+            handler,
+            _request(
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                )
+            ),
+        )
+
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    async def test_requested_summary_is_optional_when_thoughts_are_unavailable(
+        self,
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(200, json=_response()),
+            _request(reasoning=ReasoningParams(summary="auto")),
+        )
+
+        assert result.reasoning == (None,)
+
+    @pytest.mark.anyio
+    async def test_requested_summary_rejects_whitespace_only_thoughts(self) -> None:
+        with pytest.raises(
+            OutputContractError, match="empty requested thought summary"
+        ):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [{"text": " \n\t ", "thought": True}, {"text": "answer"}]
+                    ),
+                ),
+                _request(reasoning=ReasoningParams(summary="auto")),
+            )
+
+    @pytest.mark.anyio
+    async def test_truncated_reply_does_not_require_a_visible_thought_summary(
+        self,
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [{"text": " \n ", "thought": True}],
+                    finish_reason="MAX_TOKENS",
+                ),
+            ),
+            _request(reasoning=ReasoningParams(summary="auto")),
+        )
+
+        assert result.finish_reasons == ("MAX_TOKENS",)
+        assert result.reasoning is not None
+
+    @pytest.mark.anyio
+    async def test_empty_truncated_reply_preserves_prior_opaque_state(self) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "text": "prior",
+                                "thoughtSignature": "signature",
+                            }
+                        ],
+                    }
+                ],
+            },
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(parts=[], finish_reason="MAX_TOKENS"),
+            ),
+            _request(
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                )
+            ),
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == ("MAX_TOKENS",)
+        assert result.reasoning is not None
+        assert result.reasoning[0] is not None
+        assert result.reasoning[0].opaque_roundtrip == opaque
+
+    @pytest.mark.anyio
+    async def test_truncated_structured_output_preserves_partial_text(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [{"text": '{"answer":'}],
+                    finish_reason="MAX_TOKENS",
+                ),
+            ),
+            _request(structured_output=StructuredOutputParams(format="json_object")),
+        )
+
+        assert result.texts == ('{"answer":',)
+        assert result.finish_reasons == ("MAX_TOKENS",)
+        assert result.structured_output is None
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("text", ['{"a":1,"a":2}', '{"a":NaN}', "not-json"])
+    async def test_structured_output_requires_strict_json(self, text: str) -> None:
+        with pytest.raises(OutputContractError, match="valid JSON"):
+            await _run(
+                lambda _: httpx.Response(200, json=_response([{"text": text}])),
+                _request(
+                    structured_output=StructuredOutputParams(
+                        format="json_schema", schema={"type": "object"}
+                    )
+                ),
+            )
+
+    @pytest.mark.anyio
+    async def test_structured_output_uses_response_json_schema(self) -> None:
+        schema = {"type": "object", "properties": {"answer": {"type": "integer"}}}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert json.loads(request.content)["generationConfig"] == {
+                "responseMimeType": "application/json",
+                "responseJsonSchema": schema,
+            }
+            return httpx.Response(200, json=_response([{"text": '{"answer":42}'}]))
+
+        result = await _run(
+            handler,
+            _request(
+                structured_output=StructuredOutputParams(
+                    format="json_schema", schema=schema
+                )
+            ),
+        )
+        assert result.structured_output is not None
+        assert result.structured_output.value == {"answer": 42}
+
+
+class TestResponseLifting:
+    @pytest.mark.anyio
+    async def test_documented_part_metadata_is_preserved_for_replay(self) -> None:
+        part = {
+            "text": "answer",
+            "thoughtSignature": "signature",
+            "partMetadata": {"source": "provider"},
+        }
+
+        result = await _run(
+            lambda _: httpx.Response(200, json=_response([part])),
+        )
+
+        assert result.texts == ("answer",)
+        assert result.reasoning is not None and result.reasoning[0] is not None
+        opaque = json.loads(cast(str, result.reasoning[0].opaque_roundtrip))
+        assert opaque["contents"][-1]["parts"] == [part]
+
+    @pytest.mark.anyio
+    async def test_blocked_prompt_surfaces_provider_reason(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json={"promptFeedback": {"blockReason": "SAFETY"}},
+            ),
+            _request(
+                reasoning=ReasoningParams(summary="auto"),
+                structured_output=StructuredOutputParams(format="json_object"),
+            ),
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == ("SAFETY",)
+        assert result.finish_reason_sources == ("promptFeedback.blockReason",)
+        assert result.reasoning is None
+        assert result.structured_output is None
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("finish_reason", ["PROHIBITED_CONTENT", "LANGUAGE"])
+    async def test_candidate_policy_stop_is_a_scoreable_empty_outcome(
+        self, finish_reason: str
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(parts=[], finish_reason=finish_reason),
+            ),
+            _request(reasoning=ReasoningParams(summary="auto")),
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == (finish_reason,)
+        assert result.finish_reason_sources == ("candidate.finishReason",)
+        assert result.reasoning == (None,)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "finish_reason",
+        [
+            "MALFORMED_FUNCTION_CALL",
+            "UNEXPECTED_TOOL_CALL",
+            "TOO_MANY_TOOL_CALLS",
+            "MALFORMED_RESPONSE",
+        ],
+    )
+    async def test_model_output_failures_are_scoreable_empty_outcomes(
+        self, finish_reason: str
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(parts=[], finish_reason=finish_reason),
+            ),
+            _request(
+                reasoning=ReasoningParams(summary="auto"),
+                scoring=ScoringParams(sampled_logprobs=True),
+                structured_output=StructuredOutputParams(format="json_object"),
+            ),
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == (finish_reason,)
+        assert result.reasoning == (None,)
+        assert result.logprobs is None
+        assert result.structured_output is None
+
+    @pytest.mark.anyio
+    async def test_continuation_is_a_scoreable_truncated_empty_outcome(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(parts=[], finish_reason="CONTINUATION"),
+            ),
+            _request(
+                reasoning=ReasoningParams(summary="auto"),
+                scoring=ScoringParams(sampled_logprobs=True),
+                structured_output=StructuredOutputParams(format="json_object"),
+            ),
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == ("CONTINUATION",)
+        assert result.reasoning == (None,)
+        assert result.logprobs is None
+        assert result.structured_output is None
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("finish_reason", ["OTHER", "MALFORMED_FUNCTION_CALL"])
+    async def test_non_normal_finish_reason_preserves_returned_text(
+        self, finish_reason: str
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    parts=[{"text": "provider returned this text"}],
+                    finish_reason=finish_reason,
+                ),
+            )
+        )
+
+        assert result.texts == ("provider returned this text",)
+        assert result.finish_reasons == (finish_reason,)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("finish_reason", "message"),
+        [
+            ("MISSING_THOUGHT_SIGNATURE", "required thought signature"),
+            ("PUP_LIMITED_DISABLED", "account is limited or disabled"),
+        ],
+    )
+    async def test_request_or_account_failures_fail_loudly(
+        self, finish_reason: str, message: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=message):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(parts=[], finish_reason=finish_reason),
+                )
+            )
+
+    @pytest.mark.anyio
+    async def test_unspecified_prompt_block_reason_allows_candidates(self) -> None:
+        payload = _response()
+        payload["promptFeedback"] = {"blockReason": "BLOCK_REASON_UNSPECIFIED"}
+
+        result = await _run(lambda _: httpx.Response(200, json=payload))
+
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    async def test_candidates_with_prompt_block_reason_are_contradictory(self) -> None:
+        payload = _response()
+        payload["promptFeedback"] = {"blockReason": "SAFETY"}
+
+        with pytest.raises(OutputContractError, match="contradictory.*SAFETY"):
+            await _run(lambda _: httpx.Response(200, json=payload))
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("prompt_feedback", "message"),
+        [
+            ([], "promptFeedback must be an object"),
+            ({"blockReason": None}, "blockReason must be a non-empty string"),
+            ({"blockReason": ""}, "blockReason must be a non-empty string"),
+            ({"blockReason": "   "}, "blockReason must be a non-empty string"),
+            ({"blockReason": 1}, "blockReason must be a non-empty string"),
+        ],
+    )
+    async def test_malformed_prompt_feedback_fails_loudly(
+        self, prompt_feedback: object, message: str
+    ) -> None:
+        payload = _response()
+        payload["promptFeedback"] = prompt_feedback
+
+        with pytest.raises(OutputContractError, match=message):
+            await _run(lambda _: httpx.Response(200, json=payload))
+
+    @pytest.mark.anyio
+    async def test_multiple_text_candidates_preserve_choice_order(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json={
+                    "candidates": [
+                        {
+                            "index": 0,
+                            "content": {"role": "model", "parts": [{"text": "A"}]},
+                            "finishReason": "STOP",
+                        },
+                        {
+                            "index": 1,
+                            "content": {"role": "model", "parts": [{"text": "B"}]},
+                            "finishReason": "MAX_TOKENS",
+                        },
+                    ]
+                },
+            ),
+            _request(sampling=SamplingParams(n=2)),
+        )
+
+        assert result.texts == ("A", "B")
+        assert result.finish_reasons == ("STOP", "MAX_TOKENS")
+        assert result.finish_reason_sources == ("candidate.finishReason",) * 2
+
+    @pytest.mark.anyio
+    async def test_streamed_candidate_filter_preserves_distinct_source(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {"index": 0, "finishReason": "SAFETY"},
+                        ]
+                    }
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(scheduling=SchedulingParams(stream=True)),
+        )
+        assert result.texts == ("",)
+        assert result.finish_reasons == ("SAFETY",)
+        assert result.finish_reason_sources == ("candidate.finishReason",)
+
+    @pytest.mark.anyio
+    async def test_multiple_candidates_reject_singular_response_metadata(self) -> None:
+        with pytest.raises(OutputContractError, match="singular citation"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json={
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "A"}],
+                                },
+                                "finishReason": "STOP",
+                                "citationMetadata": {
+                                    "citationSources": [{"uri": "https://a.test"}]
+                                },
+                            },
+                            {
+                                "index": 1,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "B"}],
+                                },
+                                "finishReason": "STOP",
+                            },
+                        ]
+                    },
+                ),
+                _request(sampling=SamplingParams(n=2)),
+            )
+
+    @pytest.mark.anyio
+    async def test_older_model_missing_function_call_id_is_stable_and_replayable(
+        self,
+    ) -> None:
+        parts = [
+            {
+                "functionCall": {"name": "weather", "args": {"city": "Paris"}},
+                "thoughtSignature": "signature",
+            }
+        ]
+        tools = ToolParams(
+            functions=({"name": "weather", "description": "Get weather"},)
+        )
+        request = _request(tools=tools)
+        first = await _run(
+            lambda _: httpx.Response(200, json=_response(parts)),
+            request,
+        )
+        repeated = await _run(
+            lambda _: httpx.Response(200, json=_response(parts)),
+            request,
+        )
+
+        assert first.tool_calls is not None
+        call_id = first.tool_calls[0].call_id
+        assert call_id.startswith("google_call_")
+        assert repeated.tool_calls is not None
+        assert repeated.tool_calls[0].call_id == call_id
+        assert first.reasoning is not None and first.reasoning[0] is not None
+        opaque = cast(str, first.reasoning[0].opaque_roundtrip)
+        assert repeated.reasoning is not None and repeated.reasoning[0] is not None
+        assert repeated.reasoning[0].opaque_roundtrip == opaque
+        envelope = json.loads(opaque)
+        assert "id" not in envelope["contents"][-1]["parts"][0]["functionCall"]
+        assert envelope["syntheticCallIds"] == [
+            {
+                "contentIndex": 1,
+                "partIndex": 0,
+                "field": "functionCall",
+                "id": call_id,
+            }
+        ]
+
+        changed = await _run(
+            lambda _: httpx.Response(200, json=_response(parts)),
+            _request(
+                input=_chat(ChatMessage("user", (TextPart("Different input"),))),
+                tools=tools,
+            ),
+        )
+        assert changed.tool_calls is not None
+        assert changed.tool_calls[0].call_id != call_id
+
+        def handler(http_request: httpx.Request) -> httpx.Response:
+            body = json.loads(http_request.content)
+            assert body["contents"][-2]["parts"] == parts
+            assert body["contents"][-1]["parts"] == [
+                {
+                    "functionResponse": {
+                        "name": "weather",
+                        "response": {"temperature": 20},
+                    }
+                }
+            ]
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                input=_chat(
+                    ChatMessage(
+                        "tool",
+                        (ToolResultPart(call_id, {"temperature": 20}),),
+                    )
+                ),
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                ),
+            ),
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("model", ["gemini-3-pro-preview", "gemini-3.5-flash"])
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_gemini_3_rejects_a_missing_function_call_id(
+        self, model: str, stream: bool
+    ) -> None:
+        tools = ToolParams(functions=({"name": "f", "description": "Function f"},))
+        payload = _response([{"functionCall": {"name": "f", "args": {}}}])
+
+        def handler(_: httpx.Request) -> httpx.Response:
+            if stream:
+                return httpx.Response(200, content=_sse(payload))
+            return httpx.Response(200, json=payload)
+
+        with pytest.raises(
+            OutputContractError, match="response omitted the required functionCall.id"
+        ):
+            await _run(
+                handler,
+                _request(
+                    tools=tools,
+                    scheduling=SchedulingParams(stream=stream),
+                ),
+                model=model,
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("model", ["gemini-3-pro-preview", "gemini-3.5-flash"])
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_gemini_3_rejects_a_missing_function_call_thought_signature(
+        self, model: str, stream: bool
+    ) -> None:
+        tools = ToolParams(functions=({"name": "f", "description": "Function f"},))
+        payload = _response(
+            [{"functionCall": {"id": "call_1", "name": "f", "args": {}}}]
+        )
+
+        def handler(_: httpx.Request) -> httpx.Response:
+            if stream:
+                return httpx.Response(200, content=_sse(payload))
+            return httpx.Response(200, json=payload)
+
+        with pytest.raises(
+            OutputContractError,
+            match="function-call response omitted.*thoughtSignature",
+        ):
+            await _run(
+                handler,
+                _request(
+                    tools=tools,
+                    scheduling=SchedulingParams(stream=stream),
+                ),
+                model=model,
+            )
+
+    @pytest.mark.anyio
+    async def test_gemini_3_parallel_calls_require_a_signature_only_on_the_first(
+        self,
+    ) -> None:
+        tools = ToolParams(
+            functions=(
+                {"name": "first", "description": "First function"},
+                {"name": "second", "description": "Second function"},
+            )
+        )
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "functionCall": {
+                                "id": "call_a",
+                                "name": "first",
+                                "args": {},
+                            },
+                            "thoughtSignature": "signature",
+                        },
+                        {
+                            "functionCall": {
+                                "id": "call_b",
+                                "name": "second",
+                                "args": {},
+                            }
+                        },
+                    ]
+                ),
+            ),
+            _request(tools=tools),
+            model="gemini-3.5-flash",
+        )
+
+        assert result.tool_calls is not None
+        assert [call.call_id for call in result.tool_calls] == ["call_a", "call_b"]
+        assert result.reasoning is not None and result.reasoning[0] is not None
+        opaque = json.loads(cast(str, result.reasoning[0].opaque_roundtrip))
+        assert opaque["contents"][-1]["parts"] == [
+            {
+                "functionCall": {"id": "call_a", "name": "first", "args": {}},
+                "thoughtSignature": "signature",
+            },
+            {"functionCall": {"id": "call_b", "name": "second", "args": {}}},
+        ]
+
+    @pytest.mark.anyio
+    async def test_gemini_3_function_call_signature_cannot_float_to_another_part(
+        self,
+    ) -> None:
+        tools = ToolParams(functions=({"name": "f", "description": "Function f"},))
+
+        with pytest.raises(
+            OutputContractError,
+            match="function-call response omitted.*thoughtSignature",
+        ):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [
+                            {
+                                "text": "planning",
+                                "thoughtSignature": "floating_signature",
+                            },
+                            {
+                                "functionCall": {
+                                    "id": "call_1",
+                                    "name": "f",
+                                    "args": {},
+                                }
+                            },
+                        ]
+                    ),
+                ),
+                _request(tools=tools),
+                model="gemini-3.5-flash",
+            )
+
+    @pytest.mark.anyio
+    async def test_gemini_3_preserves_the_exact_function_call_id(self) -> None:
+        tools = ToolParams(functions=({"name": "f", "description": "Function f"},))
+        first = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "functionCall": {
+                                "id": "provider_call_1",
+                                "name": "f",
+                                "args": {},
+                            },
+                            "thoughtSignature": "signature",
+                        }
+                    ]
+                ),
+            ),
+            _request(tools=tools),
+            model="gemini-3.5-flash",
+        )
+
+        assert first.tool_calls is not None
+        assert first.tool_calls[0].call_id == "provider_call_1"
+        assert first.reasoning is not None and first.reasoning[0] is not None
+        opaque = cast(str, first.reasoning[0].opaque_roundtrip)
+        assert "syntheticCallIds" not in json.loads(opaque)
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["contents"][-1] == {
+                "role": "user",
+                "parts": [
+                    {
+                        "functionResponse": {
+                            "id": "provider_call_1",
+                            "name": "f",
+                            "response": {"ok": True},
+                        }
+                    }
+                ],
+            }
+            return httpx.Response(200, json=_response())
+
+        await _run(
+            handler,
+            _request(
+                input=_chat(
+                    ChatMessage(
+                        "tool", (ToolResultPart("provider_call_1", {"ok": True}),)
+                    )
+                ),
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                ),
+            ),
+            model="gemini-3.5-flash",
+        )
+
+    @pytest.mark.anyio
+    async def test_opaque_history_restores_answered_function_calls(self) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "functionCall": {"id": "call_1", "name": "f"},
+                                "thoughtSignature": "signature",
+                            }
+                        ],
+                    },
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "functionResponse": {
+                                    "id": "call_1",
+                                    "name": "f",
+                                    "response": {"ok": True},
+                                }
+                            }
+                        ],
+                    },
+                ],
+            }
+        )
+        req = _request(
+            input=_chat(
+                ChatMessage("tool", (ToolResultPart("call_1", {"again": True}),))
+            ),
+            session=SessionParams(
+                opaque_continuation=OpaqueContinuation("google_genai", opaque)
+            ),
+        )
+
+        with pytest.raises(DialectError, match="duplicate Google function result"):
+            await _run(_no_io, req)
+
+    @pytest.mark.anyio
+    async def test_older_model_may_answer_opaque_synthetic_function_call(
+        self,
+    ) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "functionCall": {"name": "f"},
+                                "thoughtSignature": "signature",
+                            }
+                        ],
+                    }
+                ],
+                "syntheticCallIds": [
+                    {
+                        "contentIndex": 0,
+                        "partIndex": 0,
+                        "field": "functionCall",
+                        "id": "call_1",
+                    }
+                ],
+            }
+        )
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["contents"][-1] == {
+                "role": "user",
+                "parts": [
+                    {
+                        "functionResponse": {
+                            "name": "f",
+                            "response": {"ok": True},
+                        }
+                    }
+                ],
+            }
+            return httpx.Response(200, json=_response())
+
+        result = await _run(
+            handler,
+            _request(
+                input=_chat(
+                    ChatMessage("tool", (ToolResultPart("call_1", {"ok": True}),))
+                ),
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                ),
+            ),
+            model="gemini-2.5-flash",
+        )
+
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    async def test_gemini_3_rejects_opaque_synthetic_function_call_ids(self) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "functionCall": {"name": "f"},
+                                "thoughtSignature": "signature",
+                            }
+                        ],
+                    }
+                ],
+                "syntheticCallIds": [
+                    {
+                        "contentIndex": 0,
+                        "partIndex": 0,
+                        "field": "functionCall",
+                        "id": "call_1",
+                    }
+                ],
+            }
+        )
+
+        with pytest.raises(
+            DialectError, match="requires every functionCall.*provider call id"
+        ):
+            await _run(
+                _no_io,
+                _request(
+                    input=_chat(
+                        ChatMessage("tool", (ToolResultPart("call_1", {"ok": True}),))
+                    ),
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    ),
+                ),
+                model="gemini-3.5-flash",
+            )
+
+    @pytest.mark.anyio
+    async def test_gemini_3_rejects_unsigned_canonical_current_turn_history(
+        self,
+    ) -> None:
+        request = _request(
+            input=_chat(
+                ChatMessage("user", (TextPart("Call the function"),)),
+                ChatMessage("assistant", (ToolCallPart("call_1", "f", {}),)),
+                ChatMessage("tool", (ToolResultPart("call_1", {"ok": True}),)),
+            ),
+            tools=ToolParams(functions=({"name": "f", "description": "Function f"},)),
+        )
+
+        with pytest.raises(
+            DialectError, match="current-turn functionCall.*thoughtSignature"
+        ):
+            await _run(_no_io, request, model="gemini-3.5-flash")
+
+    @pytest.mark.anyio
+    async def test_gemini_3_allows_unsigned_calls_before_the_current_turn(self) -> None:
+        def handler(request: httpx.Request) -> httpx.Response:
+            body = json.loads(request.content)
+            assert body["contents"][-1] == {
+                "role": "user",
+                "parts": [{"text": "Start a new turn"}],
+            }
+            return httpx.Response(200, json=_response())
+
+        result = await _run(
+            handler,
+            _request(
+                input=_chat(
+                    ChatMessage("user", (TextPart("Call the function"),)),
+                    ChatMessage("assistant", (ToolCallPart("call_1", "f", {}),)),
+                    ChatMessage("tool", (ToolResultPart("call_1", {"ok": True}),)),
+                    ChatMessage("user", (TextPart("Start a new turn"),)),
+                ),
+                tools=ToolParams(
+                    functions=({"name": "f", "description": "Function f"},)
+                ),
+            ),
+            model="gemini-3.5-flash",
+        )
+
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    async def test_gemini_3_parallel_opaque_calls_need_only_the_first_signature(
+        self,
+    ) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {"role": "user", "parts": [{"text": "Call both"}]},
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "functionCall": {"id": "call_a", "name": "first"},
+                                "thoughtSignature": "signature",
+                            },
+                            {"functionCall": {"id": "call_b", "name": "second"}},
+                        ],
+                    },
+                ],
+            }
+        )
+
+        result = await _run(
+            lambda _: httpx.Response(200, json=_response()),
+            _request(
+                input=_chat(
+                    ChatMessage(
+                        "tool",
+                        (
+                            ToolResultPart("call_a", {"first": True}),
+                            ToolResultPart("call_b", {"second": True}),
+                        ),
+                    )
+                ),
+                session=SessionParams(
+                    opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                ),
+            ),
+            model="gemini-3.5-flash",
+        )
+
+        assert result.texts == ("Hi",)
+
+    @pytest.mark.anyio
+    async def test_gemini_3_requires_a_signature_on_each_current_turn_step(
+        self,
+    ) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {"role": "user", "parts": [{"text": "Call both in order"}]},
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "functionCall": {"id": "call_a", "name": "first"},
+                                "thoughtSignature": "signature_a",
+                            }
+                        ],
+                    },
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "functionResponse": {
+                                    "id": "call_a",
+                                    "name": "first",
+                                    "response": {"ok": True},
+                                }
+                            }
+                        ],
+                    },
+                    {
+                        "role": "model",
+                        "parts": [{"functionCall": {"id": "call_b", "name": "second"}}],
+                    },
+                ],
+            }
+        )
+
+        with pytest.raises(
+            DialectError, match="current-turn functionCall.*thoughtSignature"
+        ):
+            await _run(
+                _no_io,
+                _request(
+                    input=_chat(
+                        ChatMessage("tool", (ToolResultPart("call_b", {"ok": True}),))
+                    ),
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    ),
+                ),
+                model="gemini-3.5-flash",
+            )
+
+    @pytest.mark.anyio
+    async def test_opaque_function_responses_must_be_turn_local(self) -> None:
+        opaque = json.dumps(
+            {
+                "version": 1,
+                "contents": [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {
+                                "functionCall": {"id": "call_a", "name": "first"},
+                                "thoughtSignature": "signature",
+                            }
+                        ],
+                    },
+                    {"role": "user", "parts": [{"text": "intervening"}]},
+                    {
+                        "role": "model",
+                        "parts": [{"functionCall": {"id": "call_b", "name": "second"}}],
+                    },
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "functionResponse": {
+                                    "id": "call_a",
+                                    "name": "first",
+                                    "response": {"ok": True},
+                                }
+                            },
+                            {
+                                "functionResponse": {
+                                    "id": "call_b",
+                                    "name": "second",
+                                    "response": {"ok": True},
+                                }
+                            },
+                        ],
+                    },
+                ],
+            }
+        )
+
+        with pytest.raises(DialectError, match="immediately follow.*call_a"):
+            await _run(
+                _no_io,
+                _request(
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    )
+                ),
+            )
+
+    @pytest.mark.anyio
+    async def test_usage_logprobs_citations_grounding_and_server_tools(self) -> None:
+        logprobs = {
+            "chosenCandidates": [{"token": "Hi", "logProbability": -0.1, "tokenId": 7}],
+            "topCandidates": [
+                {
+                    "candidates": [
+                        {"token": "Hi", "logProbability": -0.1, "tokenId": 7},
+                        {"token": "Hey", "logProbability": -1.2, "tokenId": 8},
+                    ]
+                }
+            ],
+        }
+        candidate_extra = {
+            "logprobsResult": logprobs,
+            "citationMetadata": {"citationSources": [{"uri": "https://cite"}]},
+            "groundingMetadata": {
+                "groundingChunks": [
+                    {"web": {"uri": "https://web", "title": "Web"}},
+                    {
+                        "image": {
+                            "sourceUri": "https://image-source",
+                            "title": "Image",
+                        }
+                    },
+                ],
+                "searchEntryPoint": {"renderedContent": "<div>sources</div>"},
+            },
+        }
+        parts = [
+            {
+                "toolCall": {
+                    "id": "server_1",
+                    "toolType": "GOOGLE_SEARCH_WEB",
+                    "args": {"q": "weather"},
+                }
+            },
+            {
+                "toolResponse": {
+                    "id": "server_1",
+                    "toolType": "GOOGLE_SEARCH_WEB",
+                    "response": {"ok": True},
+                }
+            },
+            {"text": "Hi"},
+        ]
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(parts, candidate_extra=candidate_extra),
+            ),
+            _request(
+                scoring=ScoringParams(sampled_logprobs=True, top_logprobs=2),
+                tools=ToolParams(hosted=(HostedToolSpec("google_search"),)),
+            ),
+        )
+
+        assert result.logprobs is not None and result.logprobs[0].token_id == 7
+        assert result.top_logprobs is not None
+        assert [item.token for item in result.top_logprobs[0]] == ["Hi", "Hey"]
+        assert result.citations is not None
+        assert result.citations[0].url == "https://cite"
+        assert result.grounding is not None
+        assert [chunk.uri for chunk in result.grounding.chunks] == [
+            "https://web",
+            "https://image-source",
+        ]
+        assert result.server_tool_uses is not None
+        assert result.server_tool_uses[0].tool_type == "GOOGLE_SEARCH_WEB"
+        assert result.server_tool_uses[0].result == {"ok": True}
+        assert result.usage is not None
+        assert result.usage.input_tokens == 4
+        assert result.usage.output_tokens == 3  # candidates 2 + thoughts 1
+        assert result.usage.total_tokens == 7
+        assert result.usage.reported_total_tokens is None  # matches computed total
+        assert result.usage.reasoning_tokens == 1
+        assert result.usage.cached_tokens == 2
+
+    @pytest.mark.anyio
+    async def test_missing_server_tool_ids_are_synthesized_and_paired(self) -> None:
+        parts = [
+            {
+                "toolCall": {
+                    "toolType": "GOOGLE_SEARCH_WEB",
+                    "args": {"q": "weather"},
+                },
+                "thoughtSignature": "signature",
+            },
+            {
+                "toolResponse": {
+                    "toolType": "GOOGLE_SEARCH_WEB",
+                    "response": {"ok": True},
+                }
+            },
+            {"text": "sunny"},
+        ]
+        result = await _run(
+            lambda _: httpx.Response(200, json=_response(parts)),
+            _request(tools=ToolParams(hosted=(HostedToolSpec("google_search"),))),
+        )
+
+        assert result.server_tool_uses is not None
+        tool_id = result.server_tool_uses[0].tool_use_id
+        assert tool_id.startswith("google_server_")
+        assert result.server_tool_uses[0].result == {"ok": True}
+        assert result.reasoning is not None and result.reasoning[0] is not None
+        opaque = json.loads(cast(str, result.reasoning[0].opaque_roundtrip))
+        opaque_parts = opaque["contents"][-1]["parts"]
+        assert "id" not in opaque_parts[0]["toolCall"]
+        assert "id" not in opaque_parts[1]["toolResponse"]
+        assert opaque["syntheticCallIds"] == [
+            {
+                "contentIndex": 1,
+                "partIndex": 0,
+                "field": "toolCall",
+                "id": tool_id,
+            },
+            {
+                "contentIndex": 1,
+                "partIndex": 1,
+                "field": "toolResponse",
+                "id": tool_id,
+            },
+        ]
+
+    @pytest.mark.anyio
+    async def test_usage_folds_thoughts_and_tool_use_prompt_into_parent_counts(
+        self,
+    ) -> None:
+        """toolUsePromptTokenCount + thoughtsTokenCount are addends, not breakdowns.
+
+        Google reports ``totalTokenCount = promptTokenCount + toolUsePromptTokenCount
+        + thoughtsTokenCount + candidatesTokenCount``, but the IR expects
+        ``output_tokens >= reasoning_tokens`` (reasoning is a breakdown of output).
+        Folding the addends into their parents preserves profiler share semantics.
+        """
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    usage={
+                        "promptTokenCount": 10,
+                        "toolUsePromptTokenCount": 3,
+                        "thoughtsTokenCount": 5,
+                        "candidatesTokenCount": 8,
+                        "totalTokenCount": 26,
+                    }
+                ),
+            )
+        )
+        assert result.usage is not None
+        assert result.usage.input_tokens == 13  # prompt 10 + tool_use_prompt 3
+        assert result.usage.output_tokens == 13  # candidates 8 + thoughts 5
+        assert result.usage.reasoning_tokens == 5
+        assert result.usage.total_tokens == 26
+        assert result.usage.reported_total_tokens is None  # matches computed
+
+    @pytest.mark.anyio
+    async def test_usage_computes_total_without_claiming_provider_report(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    usage={"promptTokenCount": 3, "candidatesTokenCount": 4}
+                ),
+            )
+        )
+        assert result.usage is not None
+        assert result.usage.total_tokens == 7
+        assert result.usage.reported_total_tokens is None
+
+    @pytest.mark.anyio
+    async def test_matching_provider_total_is_not_redundantly_persisted(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    usage={
+                        "promptTokenCount": 3,
+                        "candidatesTokenCount": 4,
+                        "totalTokenCount": 7,
+                    }
+                ),
+            )
+        )
+        assert result.usage is not None
+        assert result.usage.total_tokens == 7
+        assert result.usage.reported_total_tokens is None
+
+    @pytest.mark.anyio
+    async def test_requested_top_logprobs_require_exact_cardinality(self) -> None:
+        logprobs = {
+            "chosenCandidates": [{"token": "Hi", "logProbability": -0.1}],
+            "topCandidates": [
+                {"candidates": [{"token": "Hi", "logProbability": -0.1}]}
+            ],
+        }
+        with pytest.raises(OutputContractError, match="different number"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(candidate_extra={"logprobsResult": logprobs}),
+                ),
+                _request(
+                    scoring=ScoringParams(
+                        sampled_logprobs=True,
+                        top_logprobs=2,
+                    )
+                ),
+            )
+
+    @pytest.mark.anyio
+    async def test_nonempty_text_requires_chosen_logprobs(self) -> None:
+        logprobs = {"chosenCandidates": [], "topCandidates": []}
+        with pytest.raises(OutputContractError, match="without chosen logprobs"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(candidate_extra={"logprobsResult": logprobs}),
+                ),
+                _request(scoring=ScoringParams(sampled_logprobs=True)),
+            )
+
+    @pytest.mark.anyio
+    async def test_duplicate_provider_function_call_ids_fail_loudly(self) -> None:
+        with pytest.raises(OutputContractError, match="duplicate Google function call"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [
+                            {"functionCall": {"id": "same", "name": "f", "args": {}}},
+                            {"functionCall": {"id": "same", "name": "g", "args": {}}},
+                        ]
+                    ),
+                ),
+                _request(
+                    tools=ToolParams(
+                        functions=(
+                            {"name": "f", "description": "Function f"},
+                            {"name": "g", "description": "Function g"},
+                        )
+                    )
+                ),
+            )
+
+    @pytest.mark.anyio
+    async def test_provider_cannot_reuse_function_call_id_across_rounds(self) -> None:
+        tools = ToolParams(functions=({"name": "f", "description": "Function f"},))
+        first = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "functionCall": {
+                                "id": "call_1",
+                                "name": "f",
+                                "args": {},
+                            },
+                            "thoughtSignature": "signature_1",
+                        }
+                    ]
+                ),
+            ),
+            _request(tools=tools),
+        )
+        assert first.reasoning is not None and first.reasoning[0] is not None
+        opaque = cast(str, first.reasoning[0].opaque_roundtrip)
+
+        with pytest.raises(OutputContractError, match="duplicate Google function call"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [
+                            {
+                                "functionCall": {
+                                    "id": "call_1",
+                                    "name": "f",
+                                    "args": {"again": True},
+                                },
+                                "thoughtSignature": "signature_2",
+                            }
+                        ]
+                    ),
+                ),
+                _request(
+                    input=_chat(
+                        ChatMessage(
+                            "tool",
+                            (ToolResultPart("call_1", {"ok": True}),),
+                        )
+                    ),
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    ),
+                    tools=tools,
+                ),
+            )
+
+    @pytest.mark.anyio
+    async def test_provider_cannot_reuse_server_tool_id_across_rounds(self) -> None:
+        tools = ToolParams(hosted=(HostedToolSpec("google_search"),))
+        first = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "toolCall": {
+                                "id": "server_1",
+                                "toolType": "GOOGLE_SEARCH_WEB",
+                                "args": {"q": "first"},
+                            },
+                            "thoughtSignature": "signature_1",
+                        }
+                    ]
+                ),
+            ),
+            _request(tools=tools),
+        )
+        assert first.reasoning is not None and first.reasoning[0] is not None
+        opaque = cast(str, first.reasoning[0].opaque_roundtrip)
+
+        with pytest.raises(OutputContractError, match="duplicate Google server tool"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [
+                            {
+                                "toolCall": {
+                                    "id": "server_1",
+                                    "toolType": "GOOGLE_SEARCH_WEB",
+                                    "args": {"q": "second"},
+                                },
+                                "thoughtSignature": "signature_2",
+                            }
+                        ]
+                    ),
+                ),
+                _request(
+                    session=SessionParams(
+                        opaque_continuation=OpaqueContinuation("google_genai", opaque)
+                    ),
+                    tools=tools,
+                ),
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("payload", "message"),
+        [
+            (_response(finish_reason="FINISH_REASON_UNSPECIFIED"), "not terminal"),
+            (_response(candidate_extra={"index": 1}), "not ordered"),
+            (
+                _response(
+                    parts=[{"executableCode": {"language": "PYTHON", "code": "1"}}]
+                ),
+                "unsupported field",
+            ),
+            (
+                _response(
+                    parts=[{"functionCall": {"id": "c", "name": "f", "args": {}}}]
+                ),
+                "unrequested function",
+            ),
+        ],
+    )
+    async def test_unsupported_response_shapes_fail_loudly(
+        self, payload: dict[str, object], message: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=message):
+            await _run(lambda _: httpx.Response(200, json=payload))
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("tools", "returned_name"),
+        [
+            (
+                ToolParams(
+                    functions=({"name": "allowed", "description": "Allowed function"},)
+                ),
+                "other",
+            ),
+            (
+                ToolParams(
+                    functions=({"name": "allowed", "description": "Allowed function"},),
+                    choice="none",
+                ),
+                "allowed",
+            ),
+            (
+                ToolParams(
+                    functions=(
+                        {"name": "allowed", "description": "Allowed function"},
+                        {"name": "other", "description": "Other function"},
+                    ),
+                    choice={"type": "function", "name": "allowed"},
+                ),
+                "other",
+            ),
+        ],
+    )
+    async def test_response_function_call_must_be_allowed_by_the_request(
+        self, tools: ToolParams, returned_name: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match="allowed function set"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [
+                            {
+                                "functionCall": {
+                                    "id": "call_1",
+                                    "name": returned_name,
+                                    "args": {},
+                                }
+                            }
+                        ]
+                    ),
+                ),
+                _request(tools=tools),
+            )
+
+    @pytest.mark.anyio
+    async def test_selected_function_call_is_accepted(self) -> None:
+        tools = ToolParams(
+            functions=(
+                {"name": "allowed", "description": "Allowed function"},
+                {"name": "other", "description": "Other function"},
+            ),
+            choice={"type": "function", "name": "allowed"},
+        )
+
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "functionCall": {
+                                "id": "call_1",
+                                "name": "allowed",
+                                "args": {},
+                            }
+                        }
+                    ]
+                ),
+            ),
+            _request(tools=tools),
+        )
+
+        assert result.tool_calls is not None
+        assert result.tool_calls[0].name == "allowed"
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("tool", "tool_type"),
+        [
+            (HostedToolSpec("google_search"), "FILE_SEARCH"),
+            (HostedToolSpec("google_search"), "GOOGLE_SEARCH_IMAGE"),
+            (HostedToolSpec("url_context"), "GOOGLE_SEARCH_WEB"),
+        ],
+    )
+    async def test_response_server_tool_type_must_match_declared_hosted_tools(
+        self, tool: HostedToolSpec, tool_type: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match="allowed hosted-tool set"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json=_response(
+                        [
+                            {
+                                "toolCall": {
+                                    "id": "server_1",
+                                    "toolType": tool_type,
+                                    "args": {},
+                                }
+                            }
+                        ]
+                    ),
+                ),
+                _request(tools=ToolParams(hosted=(tool,))),
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("tool", "tool_type"),
+        [
+            (
+                HostedToolSpec(
+                    "google_search",
+                    {"searchTypes": {"imageSearch": {}}},
+                ),
+                "GOOGLE_SEARCH_IMAGE",
+            ),
+            (HostedToolSpec("url_context"), "URL_CONTEXT"),
+        ],
+    )
+    async def test_declared_hosted_tool_response_types_are_accepted(
+        self, tool: HostedToolSpec, tool_type: str
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json=_response(
+                    [
+                        {
+                            "toolCall": {
+                                "id": "server_1",
+                                "toolType": tool_type,
+                                "args": {},
+                            }
+                        }
+                    ]
+                ),
+            ),
+            _request(tools=ToolParams(hosted=(tool,))),
+        )
+
+        assert result.server_tool_uses is not None
+        assert result.server_tool_uses[0].tool_type == tool_type
+
+    @pytest.mark.anyio
+    async def test_missing_requested_logprobs_is_an_output_contract_error(self) -> None:
+        with pytest.raises(OutputContractError, match="omitted requested logprobs"):
+            await _run(
+                lambda _: httpx.Response(200, json=_response()),
+                _request(scoring=ScoringParams(sampled_logprobs=True)),
+            )
+
+
+class TestStreamingAndAuditEvidence:
+    @pytest.mark.anyio
+    async def test_streaming_uses_httpx_stream_mode(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        connection = _connection(
+            lambda _: httpx.Response(200, content=_sse(_response()))
+        )
+        original_send = connection.client.send
+        stream_flags: list[object] = []
+
+        async def recording_send(
+            request: httpx.Request, *, stream: bool = False
+        ) -> httpx.Response:
+            stream_flags.append(stream)
+            return await original_send(request, stream=stream)
+
+        monkeypatch.setattr(connection.client, "send", recording_send)
+        try:
+            await GoogleGenAIDialect(connection, "gemini-2.5-flash").arun(
+                _request(scheduling=SchedulingParams(stream=True))
+            )
+        finally:
+            await connection.aclose()
+
+        assert stream_flags == [True]
+
+    @pytest.mark.anyio
+    async def test_streaming_parse_failure_closes_response(self) -> None:
+        class TrackingStream(httpx.AsyncByteStream):
+            closed = False
+
+            async def __aiter__(self) -> AsyncIterator[bytes]:
+                yield b"data: not-json\n\n"
+
+            async def aclose(self) -> None:
+                self.closed = True
+
+        stream = TrackingStream()
+
+        with pytest.raises(OutputContractError, match="strict JSON"):
+            await _run(
+                lambda _: httpx.Response(200, stream=stream),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+        assert stream.closed is True
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("stream", [False, True])
+    async def test_http_error_status_fails_before_response_lifting(
+        self, stream: bool
+    ) -> None:
+        def handler(_: httpx.Request) -> httpx.Response:
+            payload = _response()
+            if stream:
+                return httpx.Response(
+                    400,
+                    content=_sse(payload),
+                    headers={"content-type": "text/event-stream"},
+                )
+            return httpx.Response(400, json=payload)
+
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            await _run(
+                handler,
+                _request(scheduling=SchedulingParams(stream=stream)),
+            )
+
+        assert "candidates" in exc_info.value.response.text
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_absolute_operation_before_credential_leak(
+        self,
+    ) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request()
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            audit.finish(prepared)
+            attacker_operation = (
+                "https://attacker.invalid/v1beta/models/"
+                "gemini-2.5-flash:generateContent"
+            )
+
+            with pytest.raises(DialectError, match="wrong prepared operation"):
+                await dialect.execute(
+                    PreparedRequest(
+                        attacker_operation,
+                        prepared.body,
+                        prepared.context,
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_streaming_uses_stream_operation_and_merges_deltas(self) -> None:
+        seen: dict[str, object] = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["url"] = str(request.url)
+            return httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "Hel"}],
+                                },
+                            }
+                        ],
+                        "modelVersion": "gemini-2.5-flash",
+                    },
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {"role": "model", "parts": [{"text": "lo"}]},
+                                "finishReason": "MAX_TOKENS",
+                            }
+                        ],
+                        "usageMetadata": {
+                            "promptTokenCount": 2,
+                            "candidatesTokenCount": 2,
+                            "totalTokenCount": 4,
+                        },
+                        "modelVersion": "gemini-2.5-flash",
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            )
+
+        result = await _run(
+            handler,
+            _request(scheduling=SchedulingParams(stream=True)),
+        )
+        assert seen["url"] == (
+            "https://generativelanguage.googleapis.com/v1beta/models/"
+            "gemini-2.5-flash:streamGenerateContent?alt=sse"
+        )
+        assert result.texts == ("Hello",)
+        assert result.finish_reasons == ("MAX_TOKENS",)
+        assert result.usage is not None
+        assert result.usage.total_tokens == 4
+        assert result.usage.output_tokens == 2
+        assert result.request_params is not None
+        assert result.request_params["query"] == {"alt": "sse"}
+
+    @pytest.mark.anyio
+    async def test_streaming_rejects_candidate_events_after_finish_reason(self) -> None:
+        with pytest.raises(
+            OutputContractError, match="candidate 0 after its terminal finishReason"
+        ):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    content=_sse(
+                        {
+                            "candidates": [
+                                {
+                                    "index": 0,
+                                    "content": {
+                                        "role": "model",
+                                        "parts": [{"text": "done"}],
+                                    },
+                                    "finishReason": "STOP",
+                                }
+                            ]
+                        },
+                        {
+                            "candidates": [
+                                {
+                                    "index": 0,
+                                    "content": {
+                                        "role": "model",
+                                        "parts": [{"text": " extra"}],
+                                    },
+                                }
+                            ]
+                        },
+                    ),
+                    headers={"content-type": "text/event-stream"},
+                ),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+    @pytest.mark.anyio
+    async def test_streaming_allows_usage_only_event_after_candidate_finishes(
+        self,
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "done"}],
+                                },
+                                "finishReason": "STOP",
+                            }
+                        ]
+                    },
+                    {
+                        "usageMetadata": {
+                            "promptTokenCount": 2,
+                            "candidatesTokenCount": 1,
+                            "totalTokenCount": 3,
+                        }
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(scheduling=SchedulingParams(stream=True)),
+        )
+
+        assert result.texts == ("done",)
+        assert result.finish_reasons == ("STOP",)
+        assert result.usage is not None
+        assert result.usage.total_tokens == 3
+
+    @pytest.mark.anyio
+    async def test_streaming_merges_reasoning_deltas_without_crossing_boundaries(
+        self,
+    ) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "ana", "thought": True}],
+                                },
+                            }
+                        ]
+                    },
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [
+                                        {
+                                            "text": "lysis",
+                                            "thought": True,
+                                            "thoughtSignature": "signature",
+                                        },
+                                        {"text": "answer"},
+                                    ],
+                                },
+                                "finishReason": "STOP",
+                            }
+                        ]
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(
+                reasoning=ReasoningParams(summary="auto"),
+                scheduling=SchedulingParams(stream=True),
+            ),
+        )
+
+        assert result.texts == ("answer",)
+        assert result.reasoning is not None
+        assert result.reasoning[0] is not None
+        assert result.reasoning[0].text == "analysis"
+        opaque = json.loads(cast(str, result.reasoning[0].opaque_roundtrip))
+        assert opaque["contents"][-1]["parts"] == [
+            {
+                "text": "analysis",
+                "thought": True,
+                "thoughtSignature": "signature",
+            },
+            {"text": "answer"},
+        ]
+
+    @pytest.mark.parametrize(
+        ("previous", "current"),
+        [
+            (
+                {"text": "reasoning", "thought": True},
+                {"text": "answer"},
+            ),
+            (
+                {"text": "before"},
+                {"functionCall": {"id": "call_1", "name": "f", "args": {}}},
+            ),
+            (
+                {
+                    "text": "signed",
+                    "thought": True,
+                    "thoughtSignature": "signature",
+                },
+                {"text": "new thought", "thought": True},
+            ),
+        ],
+    )
+    def test_streaming_text_merge_respects_semantic_boundaries(
+        self, previous: object, current: object
+    ) -> None:
+        assert google_genai._merge_stream_text_delta(previous, current) is None
+
+    @pytest.mark.anyio
+    async def test_streaming_blocked_prompt_surfaces_consistent_reason(self) -> None:
+        feedback = {"blockReason": "SAFETY", "blockReasonMessage": "unsafe"}
+
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {"promptFeedback": feedback},
+                    {
+                        "promptFeedback": {
+                            "blockReason": "SAFETY",
+                            "blockReasonMessage": "unsafe",
+                        }
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(scheduling=SchedulingParams(stream=True)),
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == ("SAFETY",)
+        assert result.finish_reason_sources == ("promptFeedback.blockReason",)
+
+    @pytest.mark.anyio
+    async def test_streaming_rejects_conflicting_prompt_feedback(self) -> None:
+        with pytest.raises(OutputContractError, match="changed promptFeedback"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    content=_sse(
+                        {"promptFeedback": {"blockReason": "BLOCK_REASON_UNSPECIFIED"}},
+                        {"promptFeedback": {"blockReason": "SAFETY"}},
+                    ),
+                    headers={"content-type": "text/event-stream"},
+                ),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+    @pytest.mark.anyio
+    async def test_streaming_does_not_persist_nonterminal_usage(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "Hel"}],
+                                },
+                            }
+                        ],
+                        "usageMetadata": {
+                            "promptTokenCount": 2,
+                            "candidatesTokenCount": 1,
+                            "totalTokenCount": 3,
+                        },
+                    },
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "lo"}],
+                                },
+                                "finishReason": "STOP",
+                            }
+                        ]
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(scheduling=SchedulingParams(stream=True)),
+        )
+
+        assert result.texts == ("Hello",)
+        assert result.usage is None
+
+    @pytest.mark.anyio
+    async def test_streaming_preserves_url_context_citations(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "answer"}],
+                                },
+                            }
+                        ]
+                    },
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "finishReason": "STOP",
+                                "urlContextMetadata": {
+                                    "urlMetadata": [
+                                        {"retrievedUrl": "https://example.test/source"}
+                                    ]
+                                },
+                            }
+                        ]
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(
+                scheduling=SchedulingParams(stream=True),
+                tools=ToolParams(hosted=(HostedToolSpec("url_context"),)),
+            ),
+        )
+
+        assert result.citations is not None
+        assert [item.url for item in result.citations] == [
+            "https://example.test/source"
+        ]
+
+    @pytest.mark.anyio
+    async def test_streaming_accumulates_grounding_chunks_in_event_order(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "grounded "}],
+                                },
+                                "groundingMetadata": {
+                                    "groundingChunks": [
+                                        {
+                                            "web": {
+                                                "uri": "https://first.test",
+                                                "title": "First",
+                                            }
+                                        }
+                                    ]
+                                },
+                            }
+                        ]
+                    },
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "answer"}],
+                                },
+                                "finishReason": "STOP",
+                                "groundingMetadata": {
+                                    "groundingChunks": [
+                                        {
+                                            "retrievedContext": {
+                                                "uri": "https://second.test",
+                                                "title": "Second",
+                                            }
+                                        }
+                                    ]
+                                },
+                            }
+                        ]
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(
+                scheduling=SchedulingParams(stream=True),
+                tools=ToolParams(hosted=(HostedToolSpec("google_search"),)),
+            ),
+        )
+
+        assert result.grounding is not None
+        assert [chunk.uri for chunk in result.grounding.chunks] == [
+            "https://first.test",
+            "https://second.test",
+        ]
+
+    def test_streaming_grounding_metadata_preserves_all_incremental_evidence(
+        self,
+    ) -> None:
+        search_entry_point = {"renderedContent": "<div>sources</div>"}
+        retrieval_metadata = {"googleSearchDynamicRetrievalScore": 0.75}
+        merged = google_genai._merge_stream_grounding_metadata(
+            None,
+            {
+                "groundingChunks": [{"web": {"uri": "https://first.test"}}],
+                "groundingSupports": [{"groundingChunkIndices": [0]}],
+                "searchEntryPoint": search_entry_point,
+                "retrievalMetadata": retrieval_metadata,
+                "googleMapsWidgetContextToken": "maps-token",
+            },
+            "groundingMetadata",
+        )
+        merged = google_genai._merge_stream_grounding_metadata(
+            merged,
+            {
+                "groundingChunks": [{"web": {"uri": "https://second.test"}}],
+                "groundingSupports": [{"groundingChunkIndices": [1]}],
+                "searchEntryPoint": {"renderedContent": "<div>sources</div>"},
+                "retrievalMetadata": {"googleSearchDynamicRetrievalScore": 0.75},
+                "googleMapsWidgetContextToken": "maps-token",
+            },
+            "groundingMetadata",
+        )
+
+        assert merged == {
+            "groundingChunks": [
+                {"web": {"uri": "https://first.test"}},
+                {"web": {"uri": "https://second.test"}},
+            ],
+            "groundingSupports": [
+                {"groundingChunkIndices": [0]},
+                {"groundingChunkIndices": [1]},
+            ],
+            "searchEntryPoint": search_entry_point,
+            "retrievalMetadata": retrieval_metadata,
+            "googleMapsWidgetContextToken": "maps-token",
+        }
+
+    @pytest.mark.anyio
+    async def test_streaming_accepts_identical_repeated_singular_metadata(
+        self,
+    ) -> None:
+        citation_metadata = {"citationSources": [{"uri": "https://citation.test"}]}
+        url_context_metadata = {
+            "urlMetadata": [{"retrievedUrl": "https://context.test"}]
+        }
+        first_candidate_metadata = {
+            "citationMetadata": citation_metadata,
+            "urlContextMetadata": url_context_metadata,
+        }
+        second_candidate_metadata = {
+            "citationMetadata": {"citationSources": [{"uri": "https://citation.test"}]},
+            "urlContextMetadata": {
+                "urlMetadata": [{"retrievedUrl": "https://context.test"}]
+            },
+        }
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                content=_sse(
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "content": {
+                                    "role": "model",
+                                    "parts": [{"text": "answer"}],
+                                },
+                                **first_candidate_metadata,
+                            }
+                        ]
+                    },
+                    {
+                        "candidates": [
+                            {
+                                "index": 0,
+                                "finishReason": "STOP",
+                                **second_candidate_metadata,
+                            }
+                        ]
+                    },
+                ),
+                headers={"content-type": "text/event-stream"},
+            ),
+            _request(scheduling=SchedulingParams(stream=True)),
+        )
+
+        assert result.citations is not None
+        assert [item.url for item in result.citations] == [
+            "https://citation.test",
+            "https://context.test",
+        ]
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("metadata_name", "first_value", "second_value"),
+        [
+            (
+                "citationMetadata",
+                {"citationSources": [{"uri": "https://first.test"}]},
+                {"citationSources": [{"uri": "https://second.test"}]},
+            ),
+            (
+                "urlContextMetadata",
+                {"urlMetadata": [{"retrievedUrl": "https://first.test"}]},
+                {"urlMetadata": [{"retrievedUrl": "https://second.test"}]},
+            ),
+            (
+                "groundingMetadata",
+                {"searchEntryPoint": {"renderedContent": "first"}},
+                {"searchEntryPoint": {"renderedContent": "second"}},
+            ),
+        ],
+    )
+    async def test_streaming_rejects_conflicting_singular_metadata(
+        self,
+        metadata_name: str,
+        first_value: Mapping[str, object],
+        second_value: Mapping[str, object],
+    ) -> None:
+        with pytest.raises(OutputContractError, match="changed .* between events"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    content=_sse(
+                        {
+                            "candidates": [
+                                {
+                                    "index": 0,
+                                    "content": {
+                                        "role": "model",
+                                        "parts": [{"text": "answer"}],
+                                    },
+                                    metadata_name: first_value,
+                                }
+                            ]
+                        },
+                        {
+                            "candidates": [
+                                {
+                                    "index": 0,
+                                    "finishReason": "STOP",
+                                    metadata_name: second_value,
+                                }
+                            ]
+                        },
+                    ),
+                    headers={"content-type": "text/event-stream"},
+                ),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("invalid_event", ["junk", [], {}])
+    async def test_streaming_rejects_non_response_data_events(
+        self, invalid_event: object
+    ) -> None:
+        terminal = {
+            "candidates": [
+                {
+                    "index": 0,
+                    "content": {"role": "model", "parts": [{"text": "answer"}]},
+                    "finishReason": "STOP",
+                }
+            ]
+        }
+        content = (
+            f"data: {json.dumps(invalid_event)}\n\ndata: {json.dumps(terminal)}\n\n"
+        ).encode()
+
+        with pytest.raises(OutputContractError, match="non-empty response object"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    content=content,
+                    headers={"content-type": "text/event-stream"},
+                ),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+    @pytest.mark.anyio
+    async def test_streaming_logprobs_are_accumulated(self) -> None:
+        def logprob(token: str, token_id: int) -> dict[str, object]:
+            return {"token": token, "logProbability": -0.1, "tokenId": token_id}
+
+        def handler(_: httpx.Request) -> httpx.Response:
+            chunks: list[dict[str, object]] = []
+            for index, token in enumerate(("A", "B")):
+                candidate: dict[str, object] = {
+                    "index": 0,
+                    "content": {"role": "model", "parts": [{"text": token}]},
+                    "logprobsResult": {
+                        "chosenCandidates": [logprob(token, index)],
+                        "topCandidates": [{"candidates": [logprob(token, index)]}],
+                    },
+                }
+                if index == 1:
+                    candidate["finishReason"] = "STOP"
+                chunks.append({"candidates": [candidate]})
+            return httpx.Response(200, content=_sse(*chunks))
+
+        result = await _run(
+            handler,
+            _request(
+                scheduling=SchedulingParams(stream=True),
+                scoring=ScoringParams(sampled_logprobs=True, top_logprobs=1),
+            ),
+        )
+        assert result.logprobs is not None
+        assert [item.token for item in result.logprobs] == ["A", "B"]
+
+    def test_input_verifier_detects_lowering_mutation(self) -> None:
+        connection = _connection(_no_io)
+        dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+        req = _request(
+            input=_chat(ChatMessage("user", (TextPart("before"), TextPart("after"))))
+        )
+        audit = RequestAudit(active_request_leaves(req))
+        dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+        prepared = dialect.prepare(req, audit)
+        body = prepared.thaw_body()
+        body["contents"] = [{"role": "user", "parts": [{"text": "afterbefore"}]}]
+
+        with pytest.raises(RequestAuditError, match="contents"):
+            audit.finish(PreparedRequest(prepared.operation, body, prepared.context))
+
+    def test_operation_verifier_detects_stream_routing_mutation(self) -> None:
+        connection = _connection(_no_io)
+        dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+        req = _request(scheduling=SchedulingParams(stream=True))
+        audit = RequestAudit(active_request_leaves(req))
+        dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+        prepared = dialect.prepare(req, audit)
+        wrong = PreparedRequest(
+            prepared.operation.replace("streamGenerateContent", "generateContent"),
+            prepared.body,
+            prepared.context,
+        )
+
+        with pytest.raises(RequestAuditError, match="operation"):
+            audit.finish(wrong)
+
+    @pytest.mark.anyio
+    async def test_malformed_sse_fails_loudly(self) -> None:
+        with pytest.raises(OutputContractError, match="malformed SSE"):
+            await _run(
+                lambda _: httpx.Response(200, content=b"not-sse\n\n"),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+
+class TestAdditionalRequestContracts:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("req", "path"),
+        [
+            (_request(sampling=SamplingParams(seed=2**31)), "sampling.seed"),
+            (_request(sampling=SamplingParams(seed=-(2**31) - 1)), "sampling.seed"),
+            (_request(sampling=SamplingParams(top_k=2**31)), "sampling.top_k"),
+            (
+                _request(sampling=SamplingParams(max_tokens=2**31)),
+                "sampling.max_tokens",
+            ),
+            (_request(sampling=SamplingParams(n=2**31)), "sampling.n"),
+            (
+                _request(reasoning=ReasoningParams(budget_tokens=2**31)),
+                "reasoning.budget_tokens",
+            ),
+        ],
+    )
+    async def test_google_int32_overflow_is_rejected_before_io(
+        self, req: Request, path: str
+    ) -> None:
+        with pytest.raises(RequestAuditError, match=re.escape(path)):
+            await _run(_no_io, req)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        "req",
+        [
+            _request(sampling=SamplingParams(seed=-(2**31))),
+            _request(sampling=SamplingParams(seed=2**31 - 1)),
+            _request(sampling=SamplingParams(top_k=2**31 - 1)),
+            _request(sampling=SamplingParams(max_tokens=2**31 - 1)),
+            _request(sampling=SamplingParams(n=2**31 - 1)),
+        ],
+    )
+    async def test_google_int32_boundaries_pass_preflight(self, req: Request) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            audit = RequestAudit(active_request_leaves(req))
+
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+
+            audit.raise_rejections()
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("req", "message"),
+        [
+            (
+                _request(
+                    input=_chat(ChatMessage(cast(Any, "alien"), (TextPart("x"),)))
+                ),
+                "invalid role",
+            ),
+            (
+                _request(input=_chat(ChatMessage("user", (TextPart(cast(Any, 1)),)))),
+                "text must be a string",
+            ),
+            (
+                _request(
+                    input=_chat(ChatMessage("user", (ImagePart(url=cast(Any, 1)),)))
+                ),
+                "url must be a string",
+            ),
+            (
+                _request(
+                    input=_chat(ChatMessage("user", (TextPart("x"),), name="named"))
+                ),
+                "no ChatMessage.name",
+            ),
+            (
+                _request(input=_chat(ChatMessage("user", ()))),
+                "empty message",
+            ),
+            (
+                _request(input=_chat(ChatMessage("tool", (TextPart("x"),)))),
+                "only tool results",
+            ),
+            (
+                _request(input=_chat(ChatMessage("tool", (ImagePart(url="x"),)))),
+                "instruction/tool messages are text-only",
+            ),
+            (
+                _request(
+                    input=_chat(ChatMessage("user", (ToolCallPart("call", "f", {}),)))
+                ),
+                "require assistant role",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage("assistant", (ToolCallPart("", "f", {}),)),
+                        ChatMessage("user", (TextPart("continue"),)),
+                    ),
+                ),
+                "call_id must be a non-empty string",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage(
+                            "assistant",
+                            (ToolCallPart("call", "f", "not-an-object"),),
+                        ),
+                        ChatMessage("user", (TextPart("continue"),)),
+                    )
+                ),
+                "arguments must be an object",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage(
+                            "assistant",
+                            (
+                                ToolCallPart("call", "f", {}),
+                                ToolCallPart("call", "f", {}),
+                            ),
+                        ),
+                        ChatMessage("user", (TextPart("continue"),)),
+                    )
+                ),
+                "duplicate Google function call id",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage("assistant", (ToolCallPart("call", "f", {}),)),
+                        ChatMessage("user", (ToolResultPart("call", {}),)),
+                    )
+                ),
+                "require tool role",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage("assistant", (ToolCallPart("call", "f", {}),)),
+                        ChatMessage("tool", (ToolResultPart("call", {}),)),
+                        ChatMessage("tool", (ToolResultPart("call", {}),)),
+                    )
+                ),
+                "duplicate Google function result",
+            ),
+            (
+                _request(input=_chat(ChatMessage("user", (ImagePart(url=""),)))),
+                "URLs must not be empty",
+            ),
+            (
+                _request(
+                    input=_chat(
+                        ChatMessage(
+                            "user", (ImagePart(data="", media_type="image/png"),)
+                        )
+                    )
+                ),
+                "inline images require data",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"type": "function", "function": "wrong"},)
+                    )
+                ),
+                "invalid OpenAI-shaped function declaration",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "f", "parameters": {}, "future": True},)
+                    )
+                ),
+                "unsupported Google function declaration field",
+            ),
+            (
+                _request(tools=ToolParams(functions=({"parameters": {}},))),
+                "requires a name",
+            ),
+            (
+                _request(tools=ToolParams(functions=({"name": "f"},))),
+                "requires a non-empty description",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "bad name!", "description": "Bad"},)
+                    )
+                ),
+                "at most 128 characters",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "f" * 129, "description": "Too long"},)
+                    )
+                ),
+                "at most 128 characters",
+            ),
+            (
+                _request(
+                    tools=ToolParams(functions=({"name": "f", "description": 1},))
+                ),
+                "description must be a string",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=(
+                            {
+                                "name": "f",
+                                "description": "Function f",
+                                "parameters": [],
+                            },
+                        )
+                    )
+                ),
+                "parameters must be an object",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "f", "description": "Function f"},),
+                        choice="sometimes",
+                    )
+                ),
+                "unsupported Google tool choice",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "f", "description": "Function f"},),
+                        choice=1,
+                    )
+                ),
+                "string or mapping",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "f", "description": "Function f"},),
+                        choice={"type": "function", "name": ""},
+                    )
+                ),
+                "requires a name",
+            ),
+            (
+                _request(
+                    tools=ToolParams(
+                        functions=({"name": "f", "description": "Function f"},),
+                        choice={"type": "function", "future": True},
+                    )
+                ),
+                "invalid Google function-specific tool choice",
+            ),
+            (
+                _request(tools=ToolParams(parallel=True)),
+                "parallel tool switch",
+            ),
+            (
+                _request(tools=ToolParams(hosted=(HostedToolSpec("code_execution"),))),
+                "unsupported Google hosted tool",
+            ),
+            (
+                _request(scoring=ScoringParams(sampled_logprobs=True, top_logprobs=21)),
+                "at most 20",
+            ),
+            (
+                _request(reasoning=ReasoningParams(effort="xhigh")),
+                "unsupported Google thinking level",
+            ),
+            (
+                _request(reasoning=ReasoningParams(summary="detailed")),
+                "supports only summary='none' or 'auto'",
+            ),
+            (
+                _request(
+                    structured_output=StructuredOutputParams(
+                        format="json_schema", schema={}, name="named"
+                    )
+                ),
+                "schemas have no name",
+            ),
+            (
+                _request(
+                    structured_output=StructuredOutputParams(
+                        format="json_schema", schema={}, strict=True
+                    )
+                ),
+                "no JSON-schema strict switch",
+            ),
+            (
+                _request(dialect_options=DialectOptions("google_genai", {"": True})),
+                "keys must be non-empty",
+            ),
+            (
+                _request(
+                    dialect_options=DialectOptions("google_genai", cast(Any, {1: True}))
+                ),
+                "option keys must be strings",
+            ),
+        ],
+    )
+    async def test_invalid_request_is_rejected_before_io(
+        self, req: Request, message: str
+    ) -> None:
+        with pytest.raises((DialectError, RequestAuditError), match=message):
+            await _run(_no_io, req)
+
+    @pytest.mark.parametrize(
+        ("req", "message"),
+        [
+            (_request(input=CompletionInput("prompt")), "requires ChatInput"),
+            (
+                _request(scoring=ScoringParams(input_scoring=True)),
+                "cannot score input tokens",
+            ),
+            (
+                _request(session=SessionParams(previous_response_id="response")),
+                "not a continuation handle",
+            ),
+            (
+                _request(
+                    structured_output=cast(
+                        Any,
+                        StructuredOutputParams(
+                            format="json_object", schema={"type": "object"}
+                        ),
+                    )
+                ),
+                "requires format='json_schema'",
+            ),
+        ],
+    )
+    def test_low_level_validation_rejects_unsupported_or_conflicting_leaves(
+        self, req: Request, message: str
+    ) -> None:
+        connection = _connection(_no_io)
+        dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+        audit = RequestAudit(active_request_leaves(req))
+
+        dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+
+        with pytest.raises(RequestAuditError, match=message):
+            audit.raise_rejections()
+
+
+class TestOpaqueContinuationBoundaries:
+    @staticmethod
+    def _payload() -> dict[str, object]:
+        return {
+            "version": 1,
+            "contents": [
+                {
+                    "role": "model",
+                    "parts": [
+                        {
+                            "text": "thought",
+                            "thought": True,
+                            "thoughtSignature": "signature",
+                        }
+                    ],
+                }
+            ],
+        }
+
+    @pytest.mark.parametrize(
+        ("mutate", "message"),
+        [
+            (lambda value: value.update(version=2), "unsupported.*version"),
+            (lambda value: value.update(contents=[]), "has no contents"),
+            (lambda value: value.update(contents=["wrong"]), "invalid shape"),
+            (
+                lambda value: value.update(contents=[{"role": "tool", "parts": [{}]}]),
+                "invalid role",
+            ),
+            (
+                lambda value: value.update(contents=[{"role": "user", "parts": []}]),
+                "has no parts",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[{"role": "user", "parts": ["wrong"]}]
+                ),
+                "is not an object",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[
+                        {
+                            "role": "user",
+                            "parts": [{"text": "x", "future": True}],
+                        }
+                    ]
+                ),
+                "unsupported field",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[
+                        {
+                            "role": "user",
+                            "parts": [{"text": "x", "fileData": {}}],
+                        }
+                    ]
+                ),
+                "one data field",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[{"role": "user", "parts": [{"text": 1}]}]
+                ),
+                "text part must contain a string",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[{"role": "user", "parts": [{"fileData": "x"}]}]
+                ),
+                "fileData must be an object",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[
+                        {"role": "model", "parts": [{"text": "x", "thought": "yes"}]}
+                    ]
+                ),
+                "thought marker must be boolean",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[
+                        {
+                            "role": "model",
+                            "parts": [{"text": "x", "thoughtSignature": ""}],
+                        }
+                    ]
+                ),
+                "thoughtSignature must be a non-empty string",
+            ),
+            (
+                lambda value: value.update(
+                    contents=[{"role": "model", "parts": [{"text": "x"}]}]
+                ),
+                "has no thought signature",
+            ),
+            (
+                lambda value: value.update(systemInstruction={}),
+                "systemInstruction has invalid shape",
+            ),
+            (
+                lambda value: value.update(systemInstruction={"parts": []}),
+                "systemInstruction has no parts",
+            ),
+            (
+                lambda value: value.update(systemInstruction={"parts": [{"text": 1}]}),
+                "systemInstruction must be text-only",
+            ),
+            (lambda value: value.update(future=True), "invalid.*envelope"),
+        ],
+    )
+    def test_malformed_opaque_continuation_is_rejected(
+        self, mutate: Callable[[dict[str, object]], None], message: str
+    ) -> None:
+        payload = self._payload()
+        mutate(payload)
+
+        with pytest.raises(DialectError, match=message):
+            google_genai._decode_opaque(json.dumps(payload))
+
+    def test_synthetic_call_metadata_preserves_an_idless_provider_part(self) -> None:
+        payload = {
+            "version": 1,
+            "contents": [
+                {
+                    "role": "model",
+                    "parts": [{"functionCall": {"name": "f", "args": {}}}],
+                }
+            ],
+            "syntheticCallIds": [
+                {
+                    "contentIndex": 0,
+                    "partIndex": 0,
+                    "field": "functionCall",
+                    "id": "google_call_local",
+                }
+            ],
+        }
+
+        _, contents, synthetic = google_genai._decode_opaque(json.dumps(payload))
+
+        assert contents[0]["parts"] == [{"functionCall": {"name": "f", "args": {}}}]
+        assert synthetic == {(0, 0, "functionCall"): "google_call_local"}
+
+    @pytest.mark.parametrize(
+        ("contents", "message"),
+        [
+            (
+                [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {"functionCall": {"name": "f", "description": "Function f"}}
+                        ],
+                    }
+                ],
+                "functionCall without a provider id has no synthetic",
+            ),
+            (
+                [{"role": "model", "parts": [{"functionCall": {"id": "c"}}]}],
+                "functionCall requires a non-empty name",
+            ),
+            (
+                [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {"functionCall": {"id": "c", "name": "f"}},
+                            {"functionCall": {"id": "c", "name": "f"}},
+                        ],
+                    }
+                ],
+                "duplicate Google function call id",
+            ),
+            (
+                [
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "functionResponse": {
+                                    "name": "f",
+                                    "description": "Function f",
+                                }
+                            }
+                        ],
+                    }
+                ],
+                "functionResponse without a provider id has no synthetic",
+            ),
+            (
+                [
+                    {
+                        "role": "user",
+                        "parts": [
+                            {
+                                "functionResponse": {
+                                    "id": "missing",
+                                    "name": "f",
+                                }
+                            }
+                        ],
+                    }
+                ],
+                "has no prior functionCall",
+            ),
+            (
+                [
+                    {
+                        "role": "model",
+                        "parts": [{"functionCall": {"id": "c", "name": "f"}}],
+                    },
+                    {
+                        "role": "user",
+                        "parts": [{"functionResponse": {"id": "c", "name": "g"}}],
+                    },
+                ],
+                "name changed",
+            ),
+            (
+                [{"role": "model", "parts": [{"toolCall": {"toolType": "SEARCH"}}]}],
+                "toolCall without a provider id has no synthetic",
+            ),
+            (
+                [{"role": "model", "parts": [{"toolCall": {"id": "s"}}]}],
+                "toolCall requires a non-empty toolType",
+            ),
+            (
+                [{"role": "user", "parts": [{"toolResponse": {"toolType": "SEARCH"}}]}],
+                "toolResponse without a provider id has no synthetic",
+            ),
+            (
+                [{"role": "user", "parts": [{"toolResponse": {"id": "s"}}]}],
+                "toolResponse requires a non-empty toolType",
+            ),
+        ],
+    )
+    def test_opaque_call_state_rejects_ambiguous_history(
+        self, contents: list[Mapping[str, object]], message: str
+    ) -> None:
+        with pytest.raises(DialectError, match=message):
+            google_genai._call_state_from_contents(cast(Any, contents), {})
+
+
+class TestAdditionalResponseContracts:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("payload", "message"),
+        [
+            ({"candidates": {}}, "response.candidates must be a sequence"),
+            ({"candidates": []}, "expected 1 Google candidates"),
+            (
+                _response(candidate_extra={"content": {"role": "user", "parts": []}}),
+                "content role is not model",
+            ),
+            (
+                _response(candidate_extra={"content": "wrong"}),
+                "content must be an object",
+            ),
+            (
+                _response(candidate_extra={"content": {"role": "model", "parts": [1]}}),
+                "response part must be an object",
+            ),
+            (
+                _response(parts=[{"text": "x", "future": True}]),
+                "unsupported field",
+            ),
+            (
+                _response(parts=[{"text": "x", "thought": "yes"}]),
+                "thought marker must be boolean",
+            ),
+            (
+                _response(parts=[{"text": "x", "thoughtSignature": ""}]),
+                "thoughtSignature must be a non-empty string",
+            ),
+            (
+                _response(parts=[{"text": "x", "functionCall": {}}]),
+                "unsupported shape",
+            ),
+            (
+                _response(parts=[{"text": 1}]),
+                "response text must be a string",
+            ),
+            (
+                _response(
+                    parts=[{"functionCall": "wrong"}],
+                    candidate_extra=None,
+                ),
+                "functionCall must be an object",
+            ),
+            (
+                _response(parts=[{"functionCall": {"name": "f", "args": []}}]),
+                "functionCall.args must be an object",
+            ),
+            (
+                _response(parts=[{"functionCall": {"name": "", "args": {}}}]),
+                "functionCall.name must be a non-empty string",
+            ),
+            (
+                _response(parts=[{"functionCall": {"id": 1, "name": "f", "args": {}}}]),
+                "functionCall.id must be a string",
+            ),
+            (
+                _response(parts=[{"toolCall": "wrong"}]),
+                "toolCall must be an object",
+            ),
+            (
+                _response(
+                    parts=[{"toolCall": {"id": "s", "toolType": "SEARCH", "args": []}}]
+                ),
+                "toolCall.args must be an object",
+            ),
+            (
+                _response(
+                    parts=[{"toolCall": {"id": 1, "toolType": "SEARCH", "args": {}}}]
+                ),
+                "toolCall.id must be a string",
+            ),
+            (
+                _response(parts=[{"toolResponse": "wrong"}]),
+                "toolResponse must be an object",
+            ),
+            (
+                _response(
+                    parts=[
+                        {
+                            "toolResponse": {
+                                "id": 1,
+                                "toolType": "SEARCH",
+                                "response": {},
+                            }
+                        }
+                    ]
+                ),
+                "toolResponse.id must be a string",
+            ),
+            (
+                _response(
+                    parts=[
+                        {
+                            "toolResponse": {
+                                "id": "s",
+                                "toolType": "SEARCH",
+                                "response": [],
+                            }
+                        }
+                    ]
+                ),
+                "toolResponse.response must be an object",
+            ),
+            (
+                _response(model_version=1),
+                "response.modelVersion must be a string or None",
+            ),
+            (
+                _response(usage=[]),
+                "usageMetadata must be an object",
+            ),
+        ],
+    )
+    async def test_malformed_provider_response_fails_loudly(
+        self, payload: Mapping[str, object], message: str
+    ) -> None:
+        # Use a valid single-family request so a model-level tool-combination
+        # rejection cannot mask the response field this case is testing.
+        server_tool_case = message.startswith(("toolCall", "toolResponse"))
+        request = _request(
+            tools=(
+                ToolParams(hosted=(HostedToolSpec("google_search"),))
+                if server_tool_case
+                else ToolParams(functions=({"name": "f", "description": "Function f"},))
+            )
+        )
+        with pytest.raises(OutputContractError, match=message):
+            await _run(lambda _: httpx.Response(200, json=payload), request)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("candidate_extra", "message"),
+        [
+            ({"citationMetadata": []}, "citationMetadata must be an object"),
+            (
+                {"citationMetadata": {"citationSources": [{}]}},
+                "uri is absent",
+            ),
+            ({"urlContextMetadata": []}, "urlContextMetadata must be an object"),
+            (
+                {"urlContextMetadata": {"urlMetadata": [{}]}},
+                "omitted its URL",
+            ),
+            ({"groundingMetadata": []}, "groundingMetadata must be an object"),
+            (
+                {"groundingMetadata": {"groundingChunks": [{}]}},
+                "is ambiguous",
+            ),
+            (
+                {"groundingMetadata": {"groundingChunks": [{"web": {}}]}},
+                "has no representable URI",
+            ),
+        ],
+    )
+    async def test_malformed_evidence_metadata_fails_loudly(
+        self, candidate_extra: Mapping[str, object], message: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=message):
+            await _run(
+                lambda _: httpx.Response(
+                    200, json=_response(candidate_extra=candidate_extra)
+                )
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("usage", "message"),
+        [
+            ({"promptTokenCount": -1}, "non-negative integer"),
+            (
+                {"promptTokenCount": 1, "candidatesTokenCount": True},
+                "non-negative integer",
+            ),
+            (
+                {
+                    "promptTokenCount": 1,
+                    "candidatesTokenCount": 1,
+                    "totalTokenCount": -1,
+                },
+                "non-negative integer",
+            ),
+            (
+                {
+                    "promptTokenCount": 1,
+                    "candidatesTokenCount": 1,
+                    "thoughtsTokenCount": -1,
+                },
+                "non-negative integer",
+            ),
+            (
+                {
+                    "promptTokenCount": 1,
+                    "candidatesTokenCount": 1,
+                    "cachedContentTokenCount": -1,
+                },
+                "non-negative integer",
+            ),
+        ],
+    )
+    async def test_malformed_usage_fails_loudly(
+        self, usage: Mapping[str, object], message: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=message):
+            await _run(lambda _: httpx.Response(200, json=_response(usage=usage)))
+
+
+class TestAdditionalStreamingContracts:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("content", "message"),
+        [
+            (b": keep-alive\n\n", "no response chunks"),
+            (b"data: not-json\n\n", "not strict JSON"),
+            (b"future: x\n\n", "unsupported SSE field"),
+            (b"data\n\n", "malformed SSE line"),
+            (b"data: []\n\n", "non-empty response object"),
+            (b"data: {}\n\n", "non-empty response object"),
+        ],
+    )
+    async def test_stream_parser_rejects_malformed_events(
+        self, content: bytes, message: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=message):
+            await _run(
+                lambda _: httpx.Response(200, content=content),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("chunks", "message"),
+        [
+            (
+                ({"candidates": [{"index": -1}]},),
+                "candidate index is invalid",
+            ),
+            (
+                (
+                    {
+                        "candidates": [
+                            {"index": 0, "content": {"role": "user", "parts": []}}
+                        ]
+                    },
+                ),
+                "candidate role is not model",
+            ),
+            (
+                ({"candidates": [{"index": 0, "groundingMetadata": []}]},),
+                "groundingMetadata must be an object",
+            ),
+            (
+                ({"candidates": [{"index": 0, "logprobsResult": []}]},),
+                "logprobsResult must be an object",
+            ),
+            (
+                (
+                    {"candidates": [{"index": 0, "finishReason": "STOP"}]},
+                    {"modelVersion": "changed"},
+                    {"modelVersion": "again"},
+                ),
+                "changed modelVersion",
+            ),
+        ],
+    )
+    async def test_stream_merge_rejects_invalid_state(
+        self, chunks: tuple[Mapping[str, object], ...], message: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=message):
+            await _run(
+                lambda _: httpx.Response(200, content=_sse(*chunks)),
+                _request(scheduling=SchedulingParams(stream=True)),
+            )
+
+
+class TestPreparedRequestAndVerifierContracts:
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("extra_tool", "with_functions"),
+        [
+            ({"urlContext": {}}, False),
+            ({"googleSearch": {}}, False),
+            ({"urlContext": {}}, True),
+        ],
+    )
+    async def test_request_audit_rejects_extra_hosted_tools(
+        self, extra_tool: dict[str, object], with_functions: bool
+    ) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-3.8-flash")
+            req = _request(
+                tools=ToolParams(
+                    functions=({"name": "lookup", "description": "Lookup"},)
+                    if with_functions
+                    else (),
+                    hosted=(HostedToolSpec("google_search"),),
+                )
+            )
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            audit.finish(prepared)
+            body = prepared.thaw_body()
+            cast(list[Any], body["tools"]).append(extra_tool)
+
+            with pytest.raises(RequestAuditError, match="hosted tools changed"):
+                audit.finish(
+                    PreparedRequest(prepared.operation, body, prepared.context)
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.parametrize(
+        ("tools", "has_functions", "expected_mismatch"),
+        [
+            ([{"googleSearch": {}}], False, None),
+            ([{"googleSearch": {}}, {"urlContext": {}}], False, "hosted tools changed"),
+            (
+                [{"googleSearch": {}}, {"googleSearch": {}}],
+                False,
+                "hosted tools changed",
+            ),
+            (
+                [
+                    {"functionDeclarations": [{"name": "unexpected"}]},
+                    {"googleSearch": {}},
+                ],
+                False,
+                "hosted tools changed",
+            ),
+            (
+                [{"functionDeclarations": [{"name": "lookup"}]}, {"googleSearch": {}}],
+                True,
+                None,
+            ),
+            (
+                [
+                    {"functionDeclarations": [{"name": "lookup"}]},
+                    {"googleSearch": {}},
+                    {"urlContext": {}},
+                ],
+                True,
+                "hosted tools changed",
+            ),
+        ],
+    )
+    def test_hosted_tools_verifier_requires_exact_tools(
+        self,
+        tools: list[dict[str, object]],
+        has_functions: bool,
+        expected_mismatch: str | None,
+    ) -> None:
+        verifier = google_genai._HostedToolsVerifier(
+            (HostedToolSpec("google_search"),), has_functions=has_functions
+        )
+        body = {
+            "tools": tools,
+            "toolConfig": {"includeServerSideToolInvocations": True},
+        }
+        assert verifier.verify(cast(Any, body)) == expected_mismatch
+
+    def test_verification_input_rejects_empty_image_url(self) -> None:
+        request_input = _chat(ChatMessage("user", (ImagePart(url=""),)))
+        with pytest.raises(DialectError, match="URLs must not be empty"):
+            google_genai._verification_input_to_wire(request_input, None)
+
+    def test_all_wire_verifiers_reject_mutated_output(self) -> None:
+        assert (
+            google_genai._InputVerifier(None, ()).verify(
+                {"contents": [], "systemInstruction": {"parts": []}}
+            )
+            == "systemInstruction no longer matches system/developer messages"
+        )
+        assert (
+            google_genai._RootOptionVerifier("serviceTier", "priority").verify({})
+            == "Google dialect option 'serviceTier' changed"
+        )
+        assert (
+            google_genai._ThinkingEffortVerifier("high").verify({})
+            == "thinking level changed"
+        )
+        assert (
+            google_genai._ReasoningSummaryVerifier().verify({})
+            == "visible-thought request changed"
+        )
+        structured = google_genai._StructuredFormatVerifier("json_schema")
+        assert structured.verify({}) == "structured output MIME type changed"
+        assert (
+            structured.verify(
+                {"generationConfig": {"responseMimeType": "application/json"}}
+            )
+            == "structured output schema presence changed"
+        )
+        functions = google_genai._FunctionsVerifier(
+            ({"name": "f", "description": "Function f"},),
+            GOOGLE_WIRE_CONTRACTS["v1beta"],
+        )
+        assert functions.verify({}) == "function tools changed"
+        hosted = google_genai._HostedToolsVerifier((HostedToolSpec("google_search"),))
+        assert hosted.verify({}) == "hosted tools changed"
+        assert (
+            hosted.verify({"tools": [{"googleSearch": {}}]})
+            == "hosted-tool invocation evidence was disabled"
+        )
+        assert (
+            google_genai._ToolChoiceVerifier(cast(Any, 1)).verify({})
+            == "source tool choice is invalid"
+        )
+        assert (
+            google_genai._ToolChoiceVerifier("auto").verify({}) == "tool choice changed"
+        )
+        assert (
+            google_genai._ToolChoiceVerifier(
+                "auto", include_server_side_invocations=True
+            ).verify(
+                {
+                    "toolConfig": {
+                        "functionCallingConfig": {"mode": "VALIDATED"},
+                        "includeServerSideToolInvocations": True,
+                    }
+                }
+            )
+            is None
+        )
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("mutation", "message"),
+        [
+            (lambda body: body.update(contents={}), "invalid contents"),
+            (lambda body: body.update(contents=["wrong"]), "invalid content items"),
+            (
+                lambda body: body.update(systemInstruction=[]),
+                "invalid systemInstruction",
+            ),
+        ],
+    )
+    async def test_execute_rejects_mutated_prepared_body_before_io(
+        self, mutation: Callable[[dict[str, object]], None], message: str
+    ) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request()
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, object], prepared.thaw_body())
+            mutation(body)
+
+            with pytest.raises(DialectError, match=message):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_invalid_prepared_context_before_io(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            with pytest.raises(DialectError, match="invalid prepared context"):
+                await dialect.execute(
+                    PreparedRequest(
+                        "v1beta/models/gemini-2.5-flash:generateContent", {}
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_unanswered_call_in_mutated_final_body(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request()
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, object], prepared.thaw_body())
+            body["contents"] = [
+                {
+                    "role": "model",
+                    "parts": [
+                        {
+                            "functionCall": {
+                                "id": "call_1",
+                                "name": "lookup",
+                                "args": {},
+                            }
+                        }
+                    ],
+                }
+            ]
+
+            with pytest.raises(DialectError, match="unanswered.*call_1"):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_globally_complete_but_delayed_call_results(
+        self,
+    ) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request()
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, object], prepared.thaw_body())
+            body["contents"] = [
+                {
+                    "role": "model",
+                    "parts": [{"functionCall": {"id": "call_a", "name": "first"}}],
+                },
+                {"role": "user", "parts": [{"text": "intervening"}]},
+                {
+                    "role": "model",
+                    "parts": [{"functionCall": {"id": "call_b", "name": "second"}}],
+                },
+                {
+                    "role": "user",
+                    "parts": [
+                        {
+                            "functionResponse": {
+                                "id": "call_a",
+                                "name": "first",
+                                "response": {"ok": True},
+                            }
+                        },
+                        {
+                            "functionResponse": {
+                                "id": "call_b",
+                                "name": "second",
+                                "response": {"ok": True},
+                            }
+                        },
+                    ],
+                },
+            ]
+
+            with pytest.raises(DialectError, match="immediately follow.*call_a"):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_missing_current_turn_thought_signature(
+        self,
+    ) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-3.5-flash")
+            req = _request()
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, object], prepared.thaw_body())
+            body["contents"] = [
+                {"role": "user", "parts": [{"text": "Call the function"}]},
+                {
+                    "role": "model",
+                    "parts": [
+                        {
+                            "functionCall": {
+                                "id": "call_1",
+                                "name": "f",
+                                "args": {},
+                            }
+                        }
+                    ],
+                },
+                {
+                    "role": "user",
+                    "parts": [
+                        {
+                            "functionResponse": {
+                                "id": "call_1",
+                                "name": "f",
+                                "response": {"ok": True},
+                            }
+                        }
+                    ],
+                },
+            ]
+
+            with pytest.raises(
+                DialectError, match="current-turn functionCall.*thoughtSignature"
+            ):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("model", "req", "mutate", "message"),
+        [
+            (
+                "gemini-3.1-pro-preview",
+                _request(reasoning=ReasoningParams(effort="low")),
+                lambda body: cast(dict[str, Any], body["generationConfig"])[
+                    "thinkingConfig"
+                ].update(thinkingLevel="MINIMAL"),
+                "supports reasoning.effort values",
+            ),
+            (
+                "gemini-2.5-pro",
+                _request(reasoning=ReasoningParams(budget_tokens=128)),
+                lambda body: cast(dict[str, Any], body["generationConfig"])[
+                    "thinkingConfig"
+                ].update(thinkingBudget=1),
+                "budget_tokens must be between 128 and 32768",
+            ),
+            (
+                "gemini-3.5-flash",
+                _request(),
+                lambda body: body.update(generationConfig={"temperature": 0.2}),
+                "sampling controls Google says to omit",
+            ),
+        ],
+    )
+    async def test_execute_revalidates_model_specific_final_body_constraints(
+        self,
+        model: str,
+        req: Request,
+        mutate: Callable[[dict[str, Any]], None],
+        message: str,
+    ) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, model)
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, Any], prepared.thaw_body())
+            mutate(body)
+
+            with pytest.raises(DialectError, match=message):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_mutated_hosted_auto_mode(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-3.8-flash")
+            req = _request(
+                tools=ToolParams(
+                    functions=({"name": "lookup", "description": "Look up a value"},),
+                    choice="auto",
+                    hosted=(HostedToolSpec("google_search"),),
+                )
+            )
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, Any], prepared.thaw_body())
+            body["toolConfig"]["functionCallingConfig"]["mode"] = "AUTO"
+
+            with pytest.raises(DialectError, match="does not support.*AUTO"):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_execute_rejects_mutated_hosted_tool_schema(self) -> None:
+        connection = _connection(_no_io)
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(tools=ToolParams(hosted=(HostedToolSpec("google_search"),)))
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, Any], prepared.thaw_body())
+            body["tools"][0]["googleSearch"] = {"unexpected": True}
+
+            with pytest.raises(DialectError, match="unsupported field.*unexpected"):
+                await dialect.execute(
+                    PreparedRequest(
+                        prepared.operation, cast(Any, body), prepared.context
+                    )
+                )
+        finally:
+            await connection.aclose()
+
+    @pytest.mark.anyio
+    async def test_request_params_come_from_final_serialized_request(self) -> None:
+        connection = _connection(lambda _: httpx.Response(200, json=_response()))
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            req = _request(sampling=SamplingParams(temperature=0.2))
+            audit = RequestAudit(active_request_leaves(req))
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+            body = cast(dict[str, object], prepared.thaw_body())
+            generation = cast(dict[str, object], body["generationConfig"])
+            generation["temperature"] = 0.9
+
+            response = await dialect.execute(
+                PreparedRequest(prepared.operation, cast(Any, body), prepared.context)
+            )
+        finally:
+            await connection.aclose()
+
+        assert response.request_params is not None
+        assert response.request_params["body"] == {
+            "generationConfig": {"temperature": 0.9}
+        }
+
+
+def _forced(obj: Any, **fields: object) -> Any:
+    """Bypass IR construction checks to reach a dialect's own defensive guards."""
+
+    for name, value in fields.items():
+        object.__setattr__(obj, name, value)
+    return obj
+
+
+def _one_message(*parts: object, role: ChatRole = "user") -> ChatInput:
+    return _chat(ChatMessage(role, cast(Any, tuple(parts))))
+
+
+class TestHistoryShapeGuards:
+    """Fail-loud guards for input the IR constructors do not themselves reject."""
+
+    @pytest.mark.parametrize(
+        ("make", "expected"),
+        [
+            (lambda: _forced(_chat(), messages=()), "at least one message"),
+            (
+                lambda: _one_message(
+                    _forced(ImagePart(url="u", media_type="image/png"), data="d")
+                ),
+                "exactly one of url or data",
+            ),
+            (
+                lambda: _one_message(_forced(ImagePart(url="u"), url=5)),
+                ".url must be a string",
+            ),
+            (
+                lambda: _one_message(
+                    _forced(ImagePart(data="d", media_type="image/png"), data=5)
+                ),
+                ".data must be a string",
+            ),
+            (
+                lambda: _one_message(_forced(ImagePart(url="u"), media_type=5)),
+                ".media_type must be a string",
+            ),
+            (
+                lambda: _one_message(_forced(ImagePart(url="u"), detail=5)),
+                ".detail must be a string",
+            ),
+            (
+                lambda: _one_message(ToolCallPart("c", "", {}), role="assistant"),
+                ".name must be a non-empty string",
+            ),
+            (
+                lambda: _one_message(ToolResultPart("", {}), role="tool"),
+                ".call_id must be a non-empty string",
+            ),
+            (
+                lambda: _one_message(
+                    _forced(ToolResultPart("c", {}), is_error="yes"), role="tool"
+                ),
+                ".is_error must be a boolean",
+            ),
+            (lambda: _one_message(object()), "has unsupported type"),
+        ],
+    )
+    def test_chat_shape_error_names_each_malformed_field(
+        self, make: Callable[[], ChatInput], expected: str
+    ) -> None:
+        error = google_genai._chat_shape_error(make())
+
+        assert error is not None
+        assert expected in error
+
+    @pytest.mark.parametrize("lower", ["main", "verification"])
+    @pytest.mark.parametrize(
+        ("image", "expected"),
+        [
+            (ImagePart(url="u", detail="high"), "per-image detail"),
+            (
+                ImagePart(url="u", media_type="image/bmp"),
+                "unsupported Google image media type",
+            ),
+            (
+                ImagePart(data="", media_type="image/png"),
+                "inline images require data",
+            ),
+            (ImagePart(data="AAAA"), "inline images require data"),
+        ],
+    )
+    def test_image_lowering_and_its_audit_mirror_reject_the_same_inputs(
+        self, lower: str, image: ImagePart, expected: str
+    ) -> None:
+        convert = (
+            google_genai._input_to_wire
+            if lower == "main"
+            else google_genai._verification_input_to_wire
+        )
+
+        with pytest.raises(DialectError, match=expected):
+            convert(_one_message(TextPart("look"), image), None)
+
+    def test_empty_image_url_is_rejected_by_lowering(self) -> None:
+        with pytest.raises(DialectError, match="URLs must not be empty"):
+            google_genai._input_to_wire(
+                _one_message(ImagePart(url="", media_type="image/png")), None
+            )
+
+    @pytest.mark.parametrize(
+        ("message", "names", "wire_ids", "answered", "expected"),
+        [
+            (
+                ChatMessage("tool", (TextPart("x"),)),
+                {},
+                {},
+                set(),
+                "may contain only tool results",
+            ),
+            (
+                ChatMessage("tool", (ImagePart(url="u"),)),
+                {},
+                {},
+                set(),
+                "may contain only tool results",
+            ),
+            (
+                ChatMessage("user", (ToolCallPart("c", "f", {}),)),
+                {},
+                {},
+                set(),
+                "require assistant role",
+            ),
+            (
+                ChatMessage("assistant", (ToolCallPart("", "f", {}),)),
+                {},
+                {},
+                set(),
+                "require id and name",
+            ),
+            (
+                ChatMessage("assistant", (ToolCallPart("c", "", {}),)),
+                {},
+                {},
+                set(),
+                "require id and name",
+            ),
+            (
+                ChatMessage("assistant", (ToolCallPart("c", "f", {}),)),
+                {"c": "f"},
+                {"c": "c"},
+                set(),
+                "duplicate Google function call id",
+            ),
+            (
+                ChatMessage("user", (ToolResultPart("c", {}),)),
+                {"c": "f"},
+                {"c": "c"},
+                set(),
+                "require tool role",
+            ),
+            (
+                ChatMessage("tool", (ToolResultPart("c", {}),)),
+                {},
+                {},
+                set(),
+                "has no prior call",
+            ),
+            (
+                ChatMessage("tool", (ToolResultPart("c", {}),)),
+                {"c": "f"},
+                {"c": "c"},
+                {"c"},
+                "duplicate Google function result",
+            ),
+            (
+                ChatMessage("user", (cast(Any, object()),)),
+                {},
+                {},
+                set(),
+                "unsupported Google content part",
+            ),
+            (
+                ChatMessage("user", ()),
+                {},
+                {},
+                set(),
+                "must not contain an empty message",
+            ),
+        ],
+    )
+    def test_content_parts_reject_each_malformed_message(
+        self,
+        message: ChatMessage,
+        names: dict[str, str],
+        wire_ids: dict[str, str | None],
+        answered: set[str],
+        expected: str,
+    ) -> None:
+        with pytest.raises(DialectError, match=expected):
+            google_genai._content_parts(message, names, answered, wire_ids, {}, 1)
+
+    def test_idless_function_response_requires_a_conversation_index(self) -> None:
+        with pytest.raises(AssertionError, match="conversation index"):
+            google_genai._content_parts(
+                ChatMessage("tool", (ToolResultPart("c", {}),)),
+                {"c": "f"},
+                set(),
+                {"c": None},
+                {},
+                None,
+            )
+
+
+def _opaque_envelope(
+    synthetic: object = None,
+    *,
+    call: object | None = None,
+    part_extra: Mapping[str, object] | None = None,
+) -> str:
+    part: dict[str, object] = {
+        "functionCall": {"name": "f", "args": {}} if call is None else call,
+        "thoughtSignature": "sig",
+    }
+    part.update(part_extra or {})
+    envelope: dict[str, object] = {
+        "version": 1,
+        "contents": [
+            {"role": "user", "parts": [{"text": "q"}]},
+            {"role": "model", "parts": [part]},
+        ],
+    }
+    if synthetic is not None:
+        envelope["syntheticCallIds"] = synthetic
+    return json.dumps(envelope)
+
+
+def _synthetic(**changes: object) -> dict[str, object]:
+    entry: dict[str, object] = {
+        "contentIndex": 1,
+        "partIndex": 0,
+        "field": "functionCall",
+        "id": "local",
+    }
+    entry.update(changes)
+    return entry
+
+
+class TestOpaqueReplayGuards:
+    def test_well_formed_synthetic_correlation_decodes(self) -> None:
+        _, contents, synthetic = google_genai._decode_opaque(
+            _opaque_envelope([_synthetic()])
+        )
+
+        assert len(contents) == 2
+        assert synthetic == {(1, 0, "functionCall"): "local"}
+
+    @pytest.mark.parametrize(
+        ("synthetic", "expected"),
+        [
+            ({}, "must be a list"),
+            ([{"contentIndex": 1}], "has invalid shape"),
+            ([_synthetic(contentIndex=-1)], "non-negative integers"),
+            ([_synthetic(partIndex=True)], "non-negative integers"),
+            ([_synthetic(field="bogus")], "has invalid field"),
+            ([_synthetic(id="")], "must be non-empty"),
+            ([_synthetic(contentIndex=9)], "points outside contents"),
+            ([_synthetic(field="functionResponse")], "points to the wrong part"),
+            ([_synthetic(), _synthetic()], "contains a duplicate"),
+        ],
+    )
+    def test_malformed_synthetic_correlation_is_rejected(
+        self, synthetic: object, expected: str
+    ) -> None:
+        with pytest.raises(DialectError, match=expected):
+            google_genai._decode_opaque(_opaque_envelope(synthetic))
+
+    def test_synthetic_id_cannot_shadow_a_provider_issued_id(self) -> None:
+        payload = _opaque_envelope(
+            [_synthetic()], call={"id": "provider", "name": "f", "args": {}}
+        )
+
+        with pytest.raises(DialectError, match="requires a call without id"):
+            google_genai._decode_opaque(payload)
+
+    @pytest.mark.parametrize(
+        "contents",
+        [
+            [{"role": "model", "parts": "not-a-list"}],
+            [{"role": "model", "parts": [{"functionCall": "not-an-object"}]}],
+        ],
+    )
+    def test_synthetic_validation_does_not_trust_unchecked_contents(
+        self, contents: list[dict[str, object]]
+    ) -> None:
+        with pytest.raises(DialectError):
+            google_genai._validate_synthetic_call_ids(
+                [_synthetic(contentIndex=0)], cast(Any, contents)
+            )
+
+    def test_malformed_part_metadata_is_rejected_on_replay(self) -> None:
+        with pytest.raises(DialectError, match="partMetadata must be an object"):
+            google_genai._decode_opaque(
+                _opaque_envelope(
+                    [_synthetic()], part_extra={"partMetadata": "not-an-object"}
+                )
+            )
+
+    @pytest.mark.parametrize(
+        ("contents", "expected"),
+        [
+            ([{"role": "user", "parts": "x"}], "parts must be a list"),
+            ([{"role": "user", "parts": ["x"]}], "must be an object"),
+            (
+                [{"role": "model", "parts": [{"functionCall": "x"}]}],
+                "history must be an object",
+            ),
+            (
+                [
+                    {
+                        "role": "model",
+                        "parts": [
+                            {"functionCall": {"id": "a", "name": "f"}},
+                            {"functionCall": {"id": "a", "name": "f"}},
+                        ],
+                    }
+                ],
+                "duplicates functionCall id",
+            ),
+        ],
+    )
+    def test_final_history_recovery_rejects_malformed_contents(
+        self, contents: list[dict[str, object]], expected: str
+    ) -> None:
+        with pytest.raises(DialectError, match=expected):
+            google_genai._historical_output_call_ids(cast(Any, contents), {})
+
+    @pytest.mark.parametrize(
+        ("output", "calls", "expected"),
+        [
+            ([], {}, "must remain an object"),
+            ({"role": "model"}, {}, "must retain parts"),
+            (
+                {"role": "model", "parts": [{"text": "x"}]},
+                {5: ("functionCall", "c")},
+                "part index changed",
+            ),
+            (
+                {"role": "model", "parts": ["x"]},
+                {0: ("functionCall", "c")},
+                "part changed shape",
+            ),
+            (
+                {"role": "model", "parts": [{"functionCall": "x"}]},
+                {0: ("functionCall", "c")},
+                "call payload changed shape",
+            ),
+            (
+                {
+                    "role": "model",
+                    "parts": [{"functionCall": {"id": "real", "name": "f"}}],
+                },
+                {0: ("functionCall", "c")},
+                "unexpectedly gained an id",
+            ),
+        ],
+    )
+    def test_opaque_history_asserts_its_internal_invariants(
+        self, output: object, calls: dict[int, tuple[str, str]], expected: str
+    ) -> None:
+        with pytest.raises(AssertionError, match=expected):
+            google_genai._opaque_history(None, (), {}, cast(Any, output), calls)
+
+
+class TestFinalBodyStructuralGuards:
+    """The final-body validators run on serialized JSON, so tolerate any shape."""
+
+    _GEMINI_3 = "gemini-3-pro-preview"
+    _JUNK: list[object] = [
+        "not-a-content",
+        {"role": "model", "parts": "not-a-list"},
+        {"role": "model", "parts": ["not-a-part"]},
+    ]
+
+    def test_call_ids_ignore_non_sequence_contents(self) -> None:
+        google_genai._validate_final_function_call_ids(
+            {"contents": "x"}, self._GEMINI_3
+        )
+
+    def test_call_id_check_still_reaches_a_later_malformed_call(self) -> None:
+        contents = [*self._JUNK, {"role": "model", "parts": [{"functionCall": "x"}]}]
+
+        with pytest.raises(DialectError, match="functionCall must be an object"):
+            google_genai._validate_final_function_call_ids(
+                cast(Any, {"contents": contents}), self._GEMINI_3
+            )
+
+    def test_signatures_ignore_non_sequence_contents(self) -> None:
+        google_genai._validate_final_function_call_signatures(
+            {"contents": None}, self._GEMINI_3
+        )
+
+    def test_signature_check_skips_junk_but_still_finds_an_unsigned_call(
+        self,
+    ) -> None:
+        google_genai._validate_final_function_call_signatures(
+            cast(Any, {"contents": self._JUNK}), self._GEMINI_3
+        )
+        contents = [
+            *self._JUNK,
+            {"role": "model", "parts": [{"functionCall": {"id": "1", "name": "f"}}]},
+        ]
+
+        with pytest.raises(DialectError, match="thoughtSignature"):
+            google_genai._validate_final_function_call_signatures(
+                cast(Any, {"contents": contents}), self._GEMINI_3
+            )
+
+
+_SEARCH = ToolParams(hosted=(HostedToolSpec("google_search"),))
+_SEARCH_CALL: dict[str, Any] = {
+    "toolCall": {"id": "s1", "toolType": "GOOGLE_SEARCH_WEB", "args": {}},
+    "thoughtSignature": "sig",
+}
+_SEARCH_RESULT: dict[str, Any] = {
+    "toolResponse": {
+        "id": "s1",
+        "toolType": "GOOGLE_SEARCH_WEB",
+        "response": {"ok": True},
+    },
+    "thoughtSignature": "sig",
+}
+
+
+def _with_model(model: str, parts: list[dict[str, Any]], **extra: Any) -> Any:
+    return _run(
+        lambda _: httpx.Response(200, json=_response(parts, **extra)),
+        _request(tools=_SEARCH),
+        model=model,
+    )
+
+
+class TestServerToolResponseGuards:
+    """Hosted-tool reply shapes that must fail loudly rather than be guessed at."""
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("parts", "expected"),
+        [
+            (
+                [
+                    {
+                        "toolCall": {
+                            "id": "s1",
+                            "toolType": "CODE_EXECUTION",
+                            "args": {},
+                        },
+                        "thoughtSignature": "sig",
+                    }
+                ],
+                "outside the request's allowed hosted-tool set",
+            ),
+            (
+                [_SEARCH_CALL, _SEARCH_RESULT, _SEARCH_RESULT],
+                "duplicate Google server tool response id",
+            ),
+            (
+                [
+                    _SEARCH_CALL,
+                    {
+                        "toolResponse": {
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "response": {},
+                        },
+                        "thoughtSignature": "sig",
+                    },
+                    {
+                        "toolResponse": {
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "response": {},
+                        },
+                        "thoughtSignature": "sig",
+                    },
+                ],
+                "without id is ambiguous",
+            ),
+            (
+                [
+                    {
+                        "toolResponse": {
+                            "id": "orphan",
+                            "toolType": "GOOGLE_SEARCH_WEB",
+                            "response": {},
+                        },
+                        "thoughtSignature": "sig",
+                    }
+                ],
+                "without its call",
+            ),
+            (
+                [
+                    _SEARCH_CALL,
+                    {
+                        "toolResponse": {
+                            "id": "s1",
+                            "toolType": "URL_CONTEXT",
+                            "response": {},
+                        },
+                        "thoughtSignature": "sig",
+                    },
+                ],
+                "server tool type changed",
+            ),
+        ],
+    )
+    async def test_inconsistent_server_tool_parts_are_rejected(
+        self, parts: list[dict[str, Any]], expected: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=expected):
+            await _with_model("gemini-3-pro-preview", parts)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("part", "expected"),
+        [
+            (_SEARCH_CALL, "unrequested server tool call"),
+            (_SEARCH_RESULT, "unrequested server tool response"),
+        ],
+    )
+    async def test_server_tool_parts_without_a_hosted_request_are_rejected(
+        self, part: dict[str, Any], expected: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=expected):
+            await _run(
+                lambda _: httpx.Response(200, json=_response([part])),
+                _request(),
+                model="gemini-3-pro-preview",
+            )
+
+    @pytest.mark.anyio
+    async def test_candidates_cannot_each_carry_singular_grounding(self) -> None:
+        grounding = {"groundingChunks": [{"web": {"uri": "https://w", "title": "t"}}]}
+        candidates = [
+            {
+                "index": index,
+                "content": {"role": "model", "parts": [{"text": "x"}]},
+                "finishReason": "STOP",
+                "groundingMetadata": grounding,
+            }
+            for index in range(2)
+        ]
+        # The n>1 gate fires first; the later ``len(groundings) > 1`` guard is
+        # unreachable (n==1 admits one candidate, so at most one grounding).
+        with pytest.raises(OutputContractError, match="cannot represent choices"):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json={
+                        "candidates": candidates,
+                        "usageMetadata": {
+                            "promptTokenCount": 1,
+                            "candidatesTokenCount": 1,
+                        },
+                    },
+                ),
+                _request(sampling=SamplingParams(n=2)),
+            )
+
+
+class TestCandidateContentGuards:
+    @pytest.mark.anyio
+    async def test_candidate_without_content_is_an_empty_scoreable_reply(self) -> None:
+        result = await _run(
+            lambda _: httpx.Response(
+                200,
+                json={
+                    "candidates": [{"index": 0, "finishReason": "SAFETY"}],
+                    "usageMetadata": {"promptTokenCount": 1, "candidatesTokenCount": 0},
+                },
+            )
+        )
+
+        assert result.texts == ("",)
+        assert result.finish_reasons == ("SAFETY",)
+
+    @pytest.mark.anyio
+    @pytest.mark.parametrize(
+        ("content", "expected"),
+        [
+            (
+                {"role": "model", "parts": [{"text": "x"}], "extra": 1},
+                "unsupported field",
+            ),
+            (
+                {"role": "model", "parts": [{"text": "x", "partMetadata": "bad"}]},
+                "partMetadata must be an object",
+            ),
+            (
+                {"role": "model", "parts": [{"text": "t", "thought": True, "x": 1}]},
+                "unsupported field",
+            ),
+            (
+                {"role": "model", "parts": [{"text": 5, "thought": True}]},
+                "exactly one text field",
+            ),
+        ],
+    )
+    async def test_malformed_candidate_content_is_rejected(
+        self, content: dict[str, Any], expected: str
+    ) -> None:
+        with pytest.raises(OutputContractError, match=expected):
+            await _run(
+                lambda _: httpx.Response(
+                    200,
+                    json={
+                        "candidates": [
+                            {"index": 0, "content": content, "finishReason": "STOP"}
+                        ],
+                        "usageMetadata": {
+                            "promptTokenCount": 1,
+                            "candidatesTokenCount": 1,
+                        },
+                    },
+                )
+            )
+
+
+class TestRequestSideGuards:
+    @pytest.mark.parametrize("summary", ["none", "auto"])
+    def test_reasoning_summary_none_is_a_documented_noop(
+        self, summary: Literal["none", "auto"]
+    ) -> None:
+        req = _request(reasoning=ReasoningParams(summary=summary))
+        audit = RequestAudit(active_request_leaves(req))
+        connection = _connection(lambda _: httpx.Response(200, json=_response()))
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            prepared = dialect.prepare(req, audit)
+        finally:
+            import asyncio
+
+            asyncio.run(connection.aclose())
+
+        generation_config = prepared.thaw_body().get("generationConfig", {})
+        assert isinstance(generation_config, dict)
+        thinking = generation_config.get("thinkingConfig", {})
+        assert isinstance(thinking, dict)
+        assert ("includeThoughts" in thinking) is (summary == "auto")
+
+    def test_multimodal_config_guards_against_future_modality_widening(self) -> None:
+        """The shared option type admits only ``image`` today.
+
+        ``_validate_multimodal_config`` is the dialect's own backstop for the day
+        ``_MULTIMODAL_INPUT_MODALITIES`` grows beyond what Gemini input maps, so
+        it is exercised by forcing a value past the option's constructor.
+        """
+
+        from sieval.core.models.capabilities import MultimodalInputOptions
+
+        google_genai._validate_multimodal_config(
+            MultimodalInputOptions(modalities=("image",))
+        )
+        widened = _forced(MultimodalInputOptions(), modalities=("image", "audio"))
+        with pytest.raises(ValueError, match="does not support modalities"):
+            google_genai._validate_multimodal_config(widened)
+
+    def test_empty_dialect_options_are_a_documented_noop(self) -> None:
+        req = _request(dialect_options=DialectOptions("google_genai", {}))
+        audit = RequestAudit(active_request_leaves(req))
+        connection = _connection(lambda _: httpx.Response(200, json=_response()))
+        try:
+            dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+            dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+            dialect.prepare(req, audit)
+        finally:
+            import asyncio
+
+            asyncio.run(connection.aclose())
+
+        assert type(audit.decisions["dialect_options"]).__name__ == "NoOp"
+
+
+class TestConstructionAndInputGuards:
+    @pytest.mark.parametrize(
+        ("model", "expected"),
+        [
+            ("", "must not be empty"),
+            ("models/", "Gemini model id"),
+            ("a/b", "Gemini model id"),
+        ],
+    )
+    def test_requested_model_id_must_name_one_gemini_model(
+        self, model: str, expected: str
+    ) -> None:
+        connection = _connection(lambda _: httpx.Response(200, json=_response()))
+        with pytest.raises(ValueError, match=expected):
+            GoogleGenAIDialect(connection, model)
+
+    def test_dialect_requires_the_provider_neutral_http_connection(self) -> None:
+        with pytest.raises(TypeError, match="AsyncHTTPJSONConnection"):
+            GoogleGenAIDialect(object(), "gemini-2.5-flash")
+
+    @pytest.mark.parametrize("convert", ["main", "verification"])
+    @pytest.mark.parametrize(
+        ("build", "expected"),
+        [
+            (lambda: _forced(_chat(), messages=()), "at least one message"),
+            (
+                lambda: _chat(
+                    ChatMessage("user", (TextPart("x"),), name="ada"),
+                ),
+                "no ChatMessage.name",
+            ),
+            (
+                lambda: _chat(
+                    ChatMessage("user", (TextPart("q"),)),
+                    ChatMessage("system", (TextPart("late"),)),
+                ),
+                "must precede conversation turns",
+            ),
+            (
+                lambda: _chat(
+                    ChatMessage("system", (ImagePart(url="u"),)),
+                    ChatMessage("user", (TextPart("q"),)),
+                ),
+                "text-only",
+            ),
+        ],
+    )
+    def test_main_path_and_audit_mirror_reject_the_same_histories(
+        self, convert: str, build: Callable[[], ChatInput], expected: str
+    ) -> None:
+        function = (
+            google_genai._input_to_wire
+            if convert == "main"
+            else google_genai._verification_input_to_wire
+        )
+
+        with pytest.raises(DialectError, match=expected):
+            function(build(), None)
+
+    @pytest.mark.parametrize("convert", ["main", "verification"])
+    def test_non_object_tool_result_is_wrapped_and_error_is_tagged(
+        self, convert: str
+    ) -> None:
+        function = (
+            google_genai._input_to_wire
+            if convert == "main"
+            else google_genai._verification_input_to_wire
+        )
+
+        def lower(result: object, *, is_error: bool = False) -> Mapping[str, object]:
+            history = _chat(
+                ChatMessage("user", (TextPart("q"),)),
+                ChatMessage("assistant", (ToolCallPart("c", "f", {}),)),
+                ChatMessage(
+                    "tool", (ToolResultPart("c", cast(Any, result), is_error=is_error),)
+                ),
+            )
+            contents = function(history, None)[1]
+            last_content = contents[-1]
+            assert isinstance(last_content, dict)
+            parts = last_content["parts"]
+            assert isinstance(parts, list)
+            first_part = parts[0]
+            assert isinstance(first_part, dict)
+            function_response = first_part["functionResponse"]
+            assert isinstance(function_response, dict)
+            return function_response
+
+        assert lower([1, 2])["response"] == {"result": [1, 2]}
+        assert lower({"a": 1})["response"] == {"a": 1}
+        assert lower("boom", is_error=True)["response"] == {"error": "boom"}
+
+    def test_tool_choice_requires_declared_function_tools(self) -> None:
+        req = _request(tools=ToolParams(choice="required"))
+        audit = RequestAudit(active_request_leaves(req))
+        connection = _connection(lambda _: httpx.Response(200, json=_response()))
+        dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+
+        dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+
+        decision = audit.decisions["tools.choice"]
+        assert isinstance(decision, Rejected)
+        assert "requires function tools" in decision.reason
+
+    def test_unsupported_structured_output_format_is_rejected(self) -> None:
+        req = _request(
+            structured_output=_forced(StructuredOutputParams(), format="xml")
+        )
+        audit = RequestAudit(active_request_leaves(req))
+        connection = _connection(lambda _: httpx.Response(200, json=_response()))
+        dialect = GoogleGenAIDialect(connection, "gemini-2.5-flash")
+
+        dialect.validate_request(req, audit, cast(Any, SimpleNamespace()))
+
+        decision = audit.decisions["structured_output.format"]
+        assert isinstance(decision, Rejected)
+        assert "unsupported Google structured output format" in decision.reason
+
+
+class TestAllowedServerToolTypes:
+    @staticmethod
+    def _allowed(*hosted: HostedToolSpec) -> frozenset[str]:
+        return google_genai._allowed_server_tool_types(
+            _request(tools=ToolParams(hosted=hosted))
+        )
+
+    def test_each_hosted_kind_maps_to_its_server_tool_types(self) -> None:
+        assert self._allowed(HostedToolSpec("url_context")) == {"URL_CONTEXT"}
+        assert self._allowed(HostedToolSpec("google_search")) == {"GOOGLE_SEARCH_WEB"}
+        assert self._allowed(
+            HostedToolSpec(
+                "google_search",
+                {"searchTypes": {"webSearch": {}, "imageSearch": {}}},
+            )
+        ) == {"GOOGLE_SEARCH_WEB", "GOOGLE_SEARCH_IMAGE"}
+        assert self._allowed(
+            HostedToolSpec("google_search", {"searchTypes": {"imageSearch": {}}})
+        ) == {"GOOGLE_SEARCH_IMAGE"}
+
+    def test_unrecognized_kind_or_search_types_shape_admits_nothing(self) -> None:
+        assert self._allowed(_forced(HostedToolSpec("google_search"), kind="x")) == (
+            frozenset()
+        )
+        assert (
+            self._allowed(HostedToolSpec("google_search", {"searchTypes": "bad"}))
+            == frozenset()
+        )
+
+
+class TestHostedToolsVerifierShape:
+    @staticmethod
+    def _body(tools: object, *, invoke: bool = True) -> dict[str, Any]:
+        body: dict[str, Any] = {"tools": tools}
+        if invoke:
+            body["toolConfig"] = {"includeServerSideToolInvocations": True}
+        return body
+
+    def _verifier(self, *, has_functions: bool = False) -> Any:
+        return google_genai._HostedToolsVerifier(
+            (HostedToolSpec("google_search"),), has_functions=has_functions
+        )
+
+    def test_exact_hosted_tool_list_verifies(self) -> None:
+        assert self._verifier().verify(self._body([{"googleSearch": {}}])) is None
+
+    @pytest.mark.parametrize(
+        "tools",
+        [
+            [{"googleSearch": {}}, {"urlContext": {}}],  # extra, unrequested tool
+            [{"googleSearch": {}}, {"googleSearch": {}}],  # duplicated tool
+            [],
+            "not-a-sequence",
+        ],
+    )
+    def test_any_deviation_from_the_requested_hosted_tools_is_detected(
+        self, tools: object
+    ) -> None:
+        assert self._verifier().verify(self._body(tools)) == "hosted tools changed"
+
+    def test_function_declarations_must_lead_when_functions_are_requested(
+        self,
+    ) -> None:
+        verifier = self._verifier(has_functions=True)
+        ok = [{"functionDeclarations": [{"name": "f"}]}, {"googleSearch": {}}]
+
+        assert verifier.verify(self._body(ok)) is None
+        for tools in (
+            [{"googleSearch": {}}],
+            [{"googleSearch": {}}, {"functionDeclarations": []}],
+            [{"functionDeclarations": [], "googleSearch": {}}],
+        ):
+            assert verifier.verify(self._body(tools)) == "hosted tools changed"
+
+    def test_non_json_tool_content_never_verifies(self) -> None:
+        assert (
+            self._verifier().verify(self._body([{"googleSearch": {1, 2}}]))
+            == "hosted tools changed"
+        )
+
+    def test_invocation_evidence_must_remain_enabled(self) -> None:
+        assert (
+            self._verifier().verify(self._body([{"googleSearch": {}}], invoke=False))
+            == "hosted-tool invocation evidence was disabled"
+        )
+
+    def test_invalid_requested_config_is_reported(self) -> None:
+        verifier = google_genai._HostedToolsVerifier(
+            (_forced(HostedToolSpec("google_search"), config="bad"),)
+        )
+
+        assert verifier.verify(self._body([])) == "hosted tool config is invalid"
+
+
+class TestStreamDeltaMerging:
+    merge = staticmethod(google_genai._merge_stream_text_delta)
+
+    def test_adjacent_text_deltas_join_into_one_part(self) -> None:
+        assert self.merge({"text": "ab"}, {"text": "cd"}) == {"text": "abcd"}
+
+    @pytest.mark.parametrize(
+        ("previous", "current"),
+        [
+            ("not-a-mapping", {"text": "x"}),
+            ({"text": "x"}, "not-a-mapping"),
+            ({"text": 1}, {"text": "x"}),
+            ({"text": "x"}, {"text": 2}),
+            ({"text": "x"}, {"text": "y", "thought": True}),
+            ({"text": "x", "thoughtSignature": "sig"}, {"text": "y"}),
+            ({"text": "x"}, {"text": "y", "thoughtSignature": ""}),
+            ({"text": "x"}, {"text": "y", "thoughtSignature": 7}),
+            ({"text": "x", "functionCall": {}}, {"text": "y"}),
+        ],
+    )
+    def test_parts_that_are_not_one_semantic_part_stay_separate(
+        self, previous: object, current: object
+    ) -> None:
+        assert self.merge(previous, current) is None
+
+    def test_signature_on_a_later_delta_closes_the_joined_part(self) -> None:
+        assert self.merge({"text": "a"}, {"text": "b", "thoughtSignature": "sig"}) == {
+            "text": "ab",
+            "thoughtSignature": "sig",
+        }
diff --git a/tests/unit/core/models/test_dialect.py b/tests/unit/core/models/test_dialect.py
index 0a4baaf7..5578a7f9 100644
--- a/tests/unit/core/models/test_dialect.py
+++ b/tests/unit/core/models/test_dialect.py
@@ -15,6 +15,7 @@
     OutputContractError,
     OutputRule,
     PreparedRequest,
+    PreparedRequestEvidence,
     RequestAudit,
     RequestAuditError,
     WireObservation,
@@ -96,6 +97,30 @@ def verify(self, body: Mapping[str, JSONValue]) -> str | None:
         raise RuntimeError("verifier bug")
 
 
+@dataclass(frozen=True)
+class _OperationVerifier:
+    expected: str
+
+    def verify_prepared(self, prepared: PreparedRequest) -> str | None:
+        if prepared.operation != self.expected:
+            return f"operation {prepared.operation!r} does not match {self.expected!r}"
+        return None
+
+
+class _DualVerifier:
+    def __init__(self) -> None:
+        self.wire_calls = 0
+        self.prepared_calls = 0
+
+    def verify(self, body: Mapping[str, JSONValue]) -> str | None:
+        self.wire_calls += 1
+        return None if body.get("stream") is True else "wire stream changed"
+
+    def verify_prepared(self, prepared: PreparedRequest) -> str | None:
+        self.prepared_calls += 1
+        return None if prepared.operation == "stream" else "operation changed"
+
+
 class TestLeafDerivation:
     def test_derives_nondefault_group_leaves_and_dynamic_none(self):
         req = Request(
@@ -314,6 +339,80 @@ def test_prepared_request_thaws_one_detached_mutable_body(self):
         assert thawed == {"extra_body": {"stop_ids": [1, 2, 3]}}
         assert prepared.body == {"extra_body": {"stop_ids": [1, 2]}}
 
+    def test_prepared_request_verifier_can_prove_operation_control_flow(self):
+        audit = RequestAudit({"scheduling.stream": True})
+        audit.consumed(
+            "scheduling.stream",
+            PreparedRequestEvidence(
+                _OperationVerifier("models/model:streamGenerateContent")
+            ),
+        )
+
+        audit.finish(
+            PreparedRequest("models/model:streamGenerateContent", {"contents": []})
+        )
+
+        with pytest.raises(RequestAuditError, match="operation.*does not match"):
+            audit.finish(
+                PreparedRequest("models/model:generateContent", {"contents": []})
+            )
+
+    def test_prepared_evidence_is_explicit_and_does_not_shadow_wire_verification(
+        self,
+    ) -> None:
+        verifier = _DualVerifier()
+        audit = RequestAudit({"scheduling.stream": True})
+        audit.consumed("scheduling.stream", verifier)
+
+        audit.finish(PreparedRequest("wrong-operation", {"stream": True}))
+
+        assert verifier.wire_calls == 1
+        assert verifier.prepared_calls == 0
+
+    def test_same_verifier_can_prove_body_and_prepared_request_independently(
+        self,
+    ) -> None:
+        verifier = _DualVerifier()
+        audit = RequestAudit({"wire": True, "operation": True})
+        audit.consumed("wire", verifier)
+        audit.consumed("operation", PreparedRequestEvidence(verifier))
+
+        audit.finish(PreparedRequest("stream", {"stream": True}))
+
+        assert verifier.wire_calls == 1
+        assert verifier.prepared_calls == 1
+
+    def test_noncallable_evidence_is_rejected_when_admitted(self) -> None:
+        audit = RequestAudit({"scheduling.stream": True})
+
+        with pytest.raises(TypeError, match=r"callable verify\(\)"):
+            audit.consumed(
+                "scheduling.stream",
+                cast(Any, type("Sneaky", (), {"verify": True})()),
+            )
+        with pytest.raises(TypeError, match=r"callable verify_prepared\(\)"):
+            PreparedRequestEvidence(
+                cast(Any, type("SneakyPrepared", (), {"verify_prepared": True})())
+            )
+
+    def test_verifier_that_loses_verify_after_admission_fails_loudly(self) -> None:
+        """Admission checks ``verify`` once; ``finish`` must not trust it blindly.
+
+        A verifier mutated between ``consumed()`` and ``finish()`` would otherwise
+        surface as an opaque ``TypeError`` from calling ``None``.
+        """
+
+        class Verifier:
+            def verify(self, body: Any) -> str | None:
+                return None
+
+        audit = RequestAudit({"scheduling.stream": True})
+        audit.consumed("scheduling.stream", Verifier())
+        Verifier.verify = cast(Any, None)
+
+        with pytest.raises(AssertionError, match=r"lost its verify\(\) method"):
+            audit.finish(PreparedRequest("op", {"stream": True}))
+
     def test_passthrough_destination_and_value_are_verified(self):
         audit = RequestAudit({"dialect_options.min_p": 0.1})
         audit.passthrough("dialect_options.min_p", "extra_body")
@@ -696,6 +795,30 @@ def test_refusal_skips_success_channel_and_continuation_requirements(self):
             Response(("",), finish_reasons=("refusal",)),
         )
 
+    def test_dialect_can_preserve_provider_refusal_spelling(self):
+        rules = _all_rules(Guarantee.BEST_EFFORT)
+        rules["reasoning"] = OutputRule(Guarantee.PRESENT_OR_ERROR)
+        contract = OutputContract(
+            rules,
+            empty_outcome_finish_reasons=frozenset({"SAFETY"}),
+        )
+
+        contract.validate(
+            _Plan(),
+            Request(
+                input=CompletionInput("x"),
+                reasoning=ReasoningParams(summary="auto"),
+            ),
+            Response(("",), finish_reasons=("SAFETY",)),
+        )
+
+    @pytest.mark.parametrize("reasons", [frozenset(), frozenset({""})])
+    def test_empty_outcome_finish_reasons_must_be_nonempty_strings(
+        self, reasons: frozenset[str]
+    ) -> None:
+        with pytest.raises(ValueError, match="empty-outcome finish reasons"):
+            OutputContract(_all_rules(), empty_outcome_finish_reasons=reasons)
+
     def test_mixed_refusal_choices_still_require_success_channels(self):
         rules = _all_rules(Guarantee.BEST_EFFORT)
         rules["reasoning"] = OutputRule(Guarantee.PRESENT_OR_ERROR)
diff --git a/tests/unit/core/models/test_dialect_registry.py b/tests/unit/core/models/test_dialect_registry.py
index 6711bdd4..c89d39b6 100644
--- a/tests/unit/core/models/test_dialect_registry.py
+++ b/tests/unit/core/models/test_dialect_registry.py
@@ -48,6 +48,7 @@
     get_dialect_spec,
 )
 from sieval.core.models.dialects.anthropic_messages import AnthropicMessagesDialect
+from sieval.core.models.dialects.google_genai import GoogleGenAIDialect
 from sieval.core.models.dialects.openai_chat import OpenAIChatDialect
 from sieval.core.models.dialects.openai_completions import OpenAICompletionsDialect
 from sieval.core.models.dialects.openai_responses import OpenAIResponsesDialect
@@ -133,7 +134,7 @@ def test_request_seed_support_is_required_and_explicit(self) -> None:
             "openai_completions": RequestSeedSupport.SUPPORTED,
             "openai_responses": RequestSeedSupport.UNSUPPORTED,
             "anthropic_messages": RequestSeedSupport.UNSUPPORTED,
-            "google_genai": RequestSeedSupport.RESERVED,
+            "google_genai": RequestSeedSupport.SUPPORTED,
             "sglang_native": RequestSeedSupport.RESERVED,
             "vllm_native": RequestSeedSupport.RESERVED,
         }
@@ -149,6 +150,7 @@ def test_implemented_dialects_are_active_and_bindable(self) -> None:
             "openai_completions",
             "openai_responses",
             "anthropic_messages",
+            "google_genai",
         }
         assert set(DIALECT_BINDERS) == active
         assert all(inspect.isfunction(binder) for binder in DIALECT_BINDERS.values())
@@ -264,8 +266,7 @@ def test_capability_decisions_are_available_only_for_active_dialects(self) -> No
         assert set(capability_decisions_for("anthropic_messages")) == set(
             CAPABILITY_KEYS
         )
-        with pytest.raises(DialectNotImplemented, match="no executable binder"):
-            capability_decisions_for("google_genai")
+        assert set(capability_decisions_for("google_genai")) == set(CAPABILITY_KEYS)
 
 
 class TestDialectBinders:
@@ -295,6 +296,7 @@ def test_reserved_dialects_fail_with_named_error(
             ("openai_completions", OpenAICompletionsDialect),
             ("openai_responses", OpenAIResponsesDialect),
             ("anthropic_messages", AnthropicMessagesDialect),
+            ("google_genai", GoogleGenAIDialect),
         ],
     )
     def test_active_binders_construct_expected_dialect(
@@ -302,7 +304,7 @@ def test_active_binders_construct_expected_dialect(
     ) -> None:
         binder = DIALECT_BINDERS[dialect_id]
         connection: object = object()
-        if dialect_id == "anthropic_messages":
+        if dialect_id in {"anthropic_messages", "google_genai"}:
             connection = AsyncHTTPJSONConnection(httpx.AsyncClient(), None)
         dialect = binder(connection, "requested-model")
 
@@ -317,6 +319,7 @@ def test_active_binders_construct_expected_dialect(
             ("openai_completions", OpenAICompletionsDialect),
             ("openai_responses", OpenAIResponsesDialect),
             ("anthropic_messages", AnthropicMessagesDialect),
+            ("google_genai", GoogleGenAIDialect),
         ],
     )
     def test_validated_runtime_plan_binds_active_dialect(
diff --git a/tests/unit/core/models/test_ir.py b/tests/unit/core/models/test_ir.py
index d235a6b8..2910d0a8 100644
--- a/tests/unit/core/models/test_ir.py
+++ b/tests/unit/core/models/test_ir.py
@@ -338,6 +338,7 @@ def test_every_root_field_declares_role_and_cardinality(self):
         assert contract["reasoning"] == ("channel", True)
         assert contract["input_scoring"] == ("channel", False)
         assert contract["provenance"] == ("provenance", False)
+        assert contract["finish_reason_sources"] == ("provenance", True)
 
     def test_reasoning_must_align_with_choices(self):
         with pytest.raises(ValueError, match="reasoning must align"):
@@ -347,6 +348,16 @@ def test_finish_reasons_must_align_with_choices(self):
         with pytest.raises(ValueError, match="finish_reasons must align"):
             Response(texts=("a", "b"), finish_reasons=("stop",))
 
+    def test_finish_reason_sources_must_align_with_reasons(self):
+        with pytest.raises(ValueError, match="finish_reason_sources must align"):
+            Response(texts=("a",), finish_reason_sources=("candidate.finishReason",))
+        with pytest.raises(ValueError, match="finish_reason_sources must align"):
+            Response(
+                texts=("a", "b"),
+                finish_reasons=("SAFETY", "STOP"),
+                finish_reason_sources=("candidate.finishReason",),
+            )
+
     def test_optional_usage_absence_differs_from_zero_usage(self):
         assert Response(texts=("x",)).usage is None
         assert UsageStats().total_tokens == 0
@@ -392,6 +403,21 @@ def _round_trip(self, response: Response) -> Response:
         assert isinstance(back, Response)
         return back
 
+    def test_finish_reason_source_survives_reload_and_old_records_default(self):
+        response = Response(
+            texts=("",),
+            finish_reasons=("SAFETY",),
+            finish_reason_sources=("promptFeedback.blockReason",),
+        )
+        persisted = obj_to_dict(response, add_type=True)
+        assert self._round_trip(response).finish_reason_sources == (
+            "promptFeedback.blockReason",
+        )
+        persisted.pop("finish_reason_sources")
+        restored = dict_to_obj(persisted, global_type_registry)
+        assert isinstance(restored, Response)
+        assert restored.finish_reason_sources is None
+
     def test_choice_indexed_reasoning_and_usage_rehydrate(self):
         back = self._round_trip(
             Response(
diff --git a/tests/unit/core/models/test_model.py b/tests/unit/core/models/test_model.py
index 9c6404e7..37f29098 100644
--- a/tests/unit/core/models/test_model.py
+++ b/tests/unit/core/models/test_model.py
@@ -55,6 +55,11 @@
     _validate_provenance_plan,
 )
 from sieval.core.models.reconcile import CheckStage, DeferredCheck, RuntimeBindingPlan
+from sieval.core.utils.serialization import (
+    dict_to_obj,
+    global_type_registry,
+    obj_to_dict,
+)
 
 
 # ---------------------------------------------------------------------------
@@ -806,6 +811,40 @@ def test_canonical_model_requires_tagged_input(self, gen_model):
 # Response metadata
 # ===================================================================
 class TestModelOutputResponseMetadata:
+    def test_finish_reason_sources_survive_record_reload(self):
+        output = ModelOutput(
+            model={"model": "gemini", "api_base": None, "default_params": {}},
+            texts=[""],
+            finish_reasons=["SAFETY"],
+            finish_reason_sources=["candidate.finishReason"],
+        )
+        persisted = obj_to_dict(output, add_type=True)
+        restored = dict_to_obj(persisted, global_type_registry)
+        assert isinstance(restored, ModelOutput)
+        assert restored.finish_reason_sources == ["candidate.finishReason"]
+
+        persisted.pop("finish_reason_sources")
+        historical = dict_to_obj(persisted, global_type_registry)
+        assert isinstance(historical, ModelOutput)
+        assert historical.finish_reason_sources is None
+
+    def test_finish_reason_sources_survive_legacy_bridge(self):
+        response = Response(
+            texts=("", ""),
+            finish_reasons=("SAFETY", "STOP"),
+            finish_reason_sources=(
+                "promptFeedback.blockReason",
+                "candidate.finishReason",
+            ),
+        )
+        output = response_to_model_output(
+            {"model": "gemini", "api_base": None, "default_params": {}}, response
+        )
+        assert output.finish_reason_sources == [
+            "promptFeedback.blockReason",
+            "candidate.finishReason",
+        ]
+
     def test_model_output_response_metadata_defaults(self):
         """New response metadata fields default to None."""
         output = ModelOutput(
diff --git a/tests/unit/core/models/test_reconcile.py b/tests/unit/core/models/test_reconcile.py
index 3b038509..13903bf3 100644
--- a/tests/unit/core/models/test_reconcile.py
+++ b/tests/unit/core/models/test_reconcile.py
@@ -1277,6 +1277,57 @@ def test_postlaunch_reconcile_rejects_realized_plan_identity_drift(self) -> None
 
 
 class TestRuntimePlanAndBinding:
+    @pytest.mark.parametrize("use_endpoints", [False, True])
+    def test_google_api_versions_have_distinct_stable_runtime_fingerprints(
+        self, use_endpoints: bool
+    ) -> None:
+        binding = dataclasses.replace(
+            _binding(dialect_id="google_genai"), requested_model_id="gemini-2.5-flash"
+        )
+        plans: dict[str, RuntimeBindingPlan] = {}
+        for version in ("v1", "v1beta"):
+            endpoint = f"https://generativelanguage.googleapis.com/{version}"
+            snapshots: list[RuntimeBindingPlan] = []
+            for _ in range(2):
+                deployment = Deployment(
+                    deployment_id=None,
+                    plan=None,
+                    engine=Engine("unknown"),
+                    engine_source="unknown",
+                    api_base="" if use_endpoints else endpoint,
+                    endpoints={"default": endpoint} if use_endpoints else {},
+                    topology=None,
+                    metrics_url=None,
+                    facts=ServingFacts(),
+                )
+                result = reconcile(
+                    _batch(
+                        binding,
+                        deployment=DeploymentReconcileInput(
+                            root_deployment_key="root",
+                            engine_id="unknown",
+                            deployment=deployment,
+                        ),
+                    )
+                )
+                assert result.is_valid, result.diagnostics
+                plan = result.runtime_plans[binding.binding_id]
+                assert plan.connection_identity.endpoint == endpoint
+                snapshots.append(plan)
+            # Equivalent reconstruction is stable, including serialized evidence.
+            assert json.dumps(
+                snapshots[0].to_json_value(), sort_keys=True
+            ) == json.dumps(snapshots[1].to_json_value(), sort_keys=True)
+            plans[version] = snapshots[0]
+
+        v1, beta = plans["v1"], plans["v1beta"]
+        # The pre-deployment capability plan has no endpoint yet.
+        assert v1.binding_plan_fingerprint == beta.binding_plan_fingerprint
+        assert v1.deployment_fingerprint != beta.deployment_fingerprint
+        assert v1.resolved_route.fingerprint != beta.resolved_route.fingerprint
+        assert v1.fingerprint != beta.fingerprint
+        assert v1.verification_fingerprint != beta.verification_fingerprint
+
     def test_external_deployment_without_plan_or_id_reconciles_and_binds(self) -> None:
         deployment = Deployment(
             deployment_id=None,
diff --git a/tests/unit/core/runners/test_runner.py b/tests/unit/core/runners/test_runner.py
index dbf5104e..53549eb3 100644
--- a/tests/unit/core/runners/test_runner.py
+++ b/tests/unit/core/runners/test_runner.py
@@ -2902,6 +2902,81 @@ async def test_counts_only_the_rollouts_that_truncated(self, tmp_path):
         # 1 of 3, which is the fact a reader of the score needs.
         assert report["n_scored_rollouts"] == 3
 
+    @pytest.mark.anyio
+    async def test_refusal_counts_in_report_and_anomalies(self, tmp_path):
+        class RefusingChatModel(MockChatModel):
+            async def _stub_arun(self, req):
+                response = await super()._stub_arun(req)
+                if prompt_of(req) != "What is 2+3?":
+                    return response
+                return replace(response, texts=("",), finish_reasons=("refusal",))
+
+        task = GenTask(
+            dataset=MockDataset(),
+            model=RefusingChatModel(answers=DEFAULT_ANSWERS),
+            name="anthropic_refusal",
+        )
+        runner = TaskRunner(task, make_config(tmp_path, detect_anomalies=True))
+        report = await runner.arun()
+
+        assert report["n_truncated"] == 1
+        assert report["n_scored_rollouts"] == 3
+        saved = orjson.loads((runner.root_dir / "report.json").read_bytes())
+        assert saved["n_truncated"] == 1
+        anomalies = orjson.loads((runner.root_dir / "anomalies.json").read_bytes())
+        assert anomalies["summary"]["anomaly_sample_details"]["truncated_output"] == 1
+
+    @pytest.mark.anyio
+    async def test_google_prompt_block_is_not_candidate_truncation_after_resume(
+        self, tmp_path
+    ):
+        class FilteredChatModel(MockChatModel):
+            async def _stub_arun(self, req):
+                response = await super()._stub_arun(req)
+                prompt = prompt_of(req)
+                if prompt == "What is 1+1?":
+                    source = "promptFeedback.blockReason"
+                elif prompt == "What is 2+3?":
+                    source = "candidate.finishReason"
+                else:
+                    return response
+                return replace(
+                    response,
+                    texts=("",),
+                    finish_reasons=("SAFETY",),
+                    finish_reason_sources=(source,),
+                )
+
+        task = GenTask(
+            dataset=MockDataset(),
+            model=FilteredChatModel(answers=DEFAULT_ANSWERS),
+            name="filtered_google",
+        )
+        runner = TaskRunner(task, make_config(tmp_path, detect_anomalies=True))
+        report = await runner.arun()
+        assert report["n_truncated"] == 1
+        assert report["n_scored_rollouts"] == 3
+        anomalies = orjson.loads((runner.root_dir / "anomalies.json").read_bytes())
+        assert anomalies["summary"]["anomaly_sample_details"]["truncated_output"] == 1
+
+        (runner.root_dir / "report.json").unlink()
+        resumed_task = GenTask(
+            dataset=MockDataset(),
+            model=FilteredChatModel(answers=DEFAULT_ANSWERS),
+            name="filtered_google",
+        )
+        resumed = TaskRunner(
+            resumed_task,
+            replace(
+                make_config(tmp_path, detect_anomalies=True),
+                result_dir=str(runner.root_dir),
+                auto_resume=True,
+            ),
+        )
+        reloaded = await resumed.arun()
+        assert reloaded["n_truncated"] == 1
+        assert reloaded["n_scored_rollouts"] == 3
+
     @pytest.mark.anyio
     async def test_clean_gen_run_reports_zero_not_nothing(self, tmp_path):
         # Present-and-zero is the point: it says the run was measured and no
diff --git a/tests/unit/core/tasks/test_anomaly.py b/tests/unit/core/tasks/test_anomaly.py
index a73d2464..12b7908c 100644
--- a/tests/unit/core/tasks/test_anomaly.py
+++ b/tests/unit/core/tasks/test_anomaly.py
@@ -182,6 +182,33 @@ def cand(logprobs, logprobs_tokens):
 
 
 class TestDetectTruncatedOutput:
+    def test_prompt_block_is_never_output_truncation(self, sample_model_meta):
+        output = ModelOutput(
+            model=sample_model_meta,
+            texts=[""],
+            finish_reasons=["content_filter"],
+            finish_reason_sources=["promptFeedback.blockReason"],
+        )
+        assert detect_truncated_output(_make_final_ctx(infer_result=output)) == set()
+
+    def test_google_candidate_filter_not_prompt_block(self, sample_model_meta):
+        for reason in ("SAFETY", "LANGUAGE"):
+            for source, expected in (
+                ("candidate.finishReason", {0}),
+                ("promptFeedback.blockReason", set()),
+                (None, set()),
+            ):
+                output = ModelOutput(
+                    model=sample_model_meta,
+                    texts=[""],
+                    finish_reasons=[reason],
+                    finish_reason_sources=[source] if source is not None else None,
+                )
+                assert (
+                    detect_truncated_output(_make_final_ctx(infer_result=output))
+                    == expected
+                ), (reason, source)
+
     def test_single_sample(self, sample_model_meta):
         """Single-sample (n=1) finish reason variants."""
         cases = [
@@ -193,7 +220,10 @@ def test_single_sample(self, sample_model_meta):
                 {0},
                 "model_context_window_exceeded",
             ),
+            (["MAX_TOKENS"], {0}, "MAX_TOKENS"),
             (["content_filter"], {0}, "content_filter"),
+            (["refusal"], {0}, "refusal"),
+            (["end_turn"], set(), "end_turn"),
             (["stop"], set(), "stop"),
             (None, set(), "missing_finish_reasons"),
         ]
@@ -555,6 +585,28 @@ async def test_needs_regeneration_transitions(self, tmp_path):
         await detector.load()
         assert detector.needs_regeneration() is False
 
+    @pytest.mark.anyio
+    async def test_previous_filter_rule_hash_is_backed_up_and_regenerated(
+        self, tmp_path
+    ):
+        detector = TaskAnomalyDetector(root_dir=tmp_path)
+        ctx = _make_final_ctx(postprocess_result="answer")
+        previous = detector.generate_report({0: ctx}, "t", task_tags={"gen"})
+        previous["meta"]["rules_hash"] = "1d61bae98de6f417"
+        previous["meta"]["generated_at"] = "2026-08-07T01:02:03+00:00"
+        await detector.save(previous, backup_if_changed=False)
+
+        await detector.load()
+        assert detector.needs_regeneration() is True
+        current = await detector.generate_and_save(
+            {0: ctx}, "t", task_tags={"gen"}, backup_if_changed=True
+        )
+
+        assert current["meta"]["rules_hash"] == "2c440347324b1edb"
+        backup = orjson.loads((tmp_path / "anomalies.20260807010203.json").read_bytes())
+        assert backup["meta"]["rules_hash"] == "1d61bae98de6f417"
+        assert detector.needs_regeneration() is False
+
     @pytest.mark.anyio
     async def test_save_backup_when_rules_changed(self, tmp_path, sample_model_meta):
         detector = TaskAnomalyDetector(root_dir=tmp_path)
@@ -949,13 +1001,13 @@ def test_the_hash_is_pinned_to_the_current_rule_set(self):
         value here in the same commit, so the rotation is in the diff rather than
         discovered in production.
 
-        Rotated once here, deliberately: `empty_infer_ppl` was inert for every ppl
-        task, and repairing it has to reach the runs already on disk. Its
-        description now says "any candidate's" — the accurate reading, and what
-        moves this hash. Without that, `needs_regeneration()` returns False and
-        every stored report keeps the dead rule's verdict.
+        Rotated first for `empty_infer_ppl` reading every candidate and
+        `truncated_output` counting filtered candidates without misclassifying
+        blocked prompts; rotated again to include unsupported languages and
+        Anthropic refusals. Each change must reach stored anomaly reports;
+        without a new hash, `needs_regeneration()` returns False.
         """
-        assert get_rules_hash() == "56480a99ae65a3c0"
+        assert get_rules_hash() == "2c440347324b1edb"
 
     def test_the_rule_set_is_the_expected_size(self):
         # Guards the other direction: a rule silently dropped from the registry
diff --git a/tests/unit/core/utils/test_meta.py b/tests/unit/core/utils/test_meta.py
index eb910cca..3dc1d73d 100644
--- a/tests/unit/core/utils/test_meta.py
+++ b/tests/unit/core/utils/test_meta.py
@@ -20,6 +20,17 @@
 
 
 class TestBuildModelCallMeta:
+    def test_finish_reason_sources_survive_metadata_round_trip(self, sample_model_meta):
+        output = ModelOutput(
+            model=sample_model_meta,
+            texts=[""],
+            finish_reasons=["SAFETY"],
+            finish_reason_sources=["candidate.finishReason"],
+        )
+        meta = build_model_call_meta(output)
+        assert meta["finish_reason_sources"] == ["candidate.finishReason"]
+        assert build_model_call_meta_from_mapping({**meta, "texts": [""]}) == meta
+
     def test_full_output(self, sample_model_output):
         meta = build_model_call_meta(sample_model_output)
         assert meta["model"] == sample_model_output.model
@@ -265,7 +276,7 @@ def _inferred(*calls: dict) -> dict:
 
 
 class TestCountTruncatedRollouts:
-    """The report-level count of rollouts that ran out of budget.
+    """The report-level count of rollouts whose output was interrupted.
 
     Semantics are pinned against `detect_truncated_output`, which reduces the
     same event off the live output rather than the persisted meta: the two must
@@ -307,20 +318,102 @@ def test_counts_rollouts_not_samples(self):
     def test_every_provider_spelling_counts(self):
         # The IR keeps finish_reasons provider-verbatim: OpenAI-compatible
         # Chat/Completions and SGLang native say `length`, Responses says
-        # `max_output_tokens`, and Anthropic says either `max_tokens` or
-        # `model_context_window_exceeded`. A set holding only one spelling would
-        # silently read zero on another provider.
+        # `max_output_tokens`, Anthropic says `max_tokens` or
+        # `model_context_window_exceeded`, and Google says `MAX_TOKENS` or
+        # `CONTINUATION`. A set holding only one spelling would silently read
+        # zero on another provider.
         for reason in (
             "length",
             "max_output_tokens",
             "max_tokens",
             "model_context_window_exceeded",
+            "MAX_TOKENS",
+            "CONTINUATION",
             "content_filter",
+            "refusal",
         ):
             assert (
                 count_truncated_rollouts([_inferred({"finish_reasons": [reason]})]) == 1
             )
 
+    def test_anthropic_refusal_and_natural_stop(self):
+        calls = _inferred({"finish_reasons": ["refusal", "end_turn"]})
+        assert count_truncated_rollouts([calls]) == 1
+        assert count_scored_rollouts([calls]) == 2
+
+    def test_google_policy_counts_only_candidate_stops(self):
+        reasons = (
+            "SAFETY",
+            "RECITATION",
+            "LANGUAGE",
+            "BLOCKLIST",
+            "PROHIBITED_CONTENT",
+            "SPII",
+            "IMAGE_SAFETY",
+            "IMAGE_PROHIBITED_CONTENT",
+            "IMAGE_RECITATION",
+            "ESCALATION",
+        )
+        for reason in reasons:
+            candidate = _inferred(
+                {
+                    "finish_reasons": [reason],
+                    "finish_reason_sources": ["candidate.finishReason"],
+                }
+            )
+            prompt = _inferred(
+                {
+                    "finish_reasons": [reason],
+                    "finish_reason_sources": ["promptFeedback.blockReason"],
+                }
+            )
+            assert count_truncated_rollouts([candidate]) == 1
+            assert count_truncated_rollouts([prompt]) == 0
+            assert (
+                count_truncated_rollouts([_inferred({"finish_reasons": [reason]})]) == 0
+            )
+
+    def test_prompt_feedback_with_repeated_choices_is_not_truncation(self):
+        blocked = _inferred(
+            {
+                "finish_reasons": ["SAFETY", "SAFETY"],
+                "finish_reason_sources": ["promptFeedback.blockReason"] * 2,
+            }
+        )
+        assert count_truncated_rollouts([blocked]) == 0
+        assert count_scored_rollouts([blocked]) == 2
+
+    def test_prompt_feedback_source_takes_priority_over_stop_spelling(self):
+        for reason in ("MAX_TOKENS", "content_filter"):
+            blocked = _inferred(
+                {
+                    "finish_reasons": [reason],
+                    "finish_reason_sources": ["promptFeedback.blockReason"],
+                }
+            )
+            assert count_truncated_rollouts([blocked]) == 0
+
+    def test_google_multi_candidate_counts_only_filtered_candidates(self):
+        assert (
+            count_truncated_rollouts(
+                [
+                    _inferred(
+                        {
+                            "finish_reasons": ["STOP", "SAFETY", "STOP"],
+                            "finish_reason_sources": ["candidate.finishReason"] * 3,
+                        }
+                    )
+                ]
+            )
+            == 1
+        )
+
+    def test_budget_limit_counts_without_source(self):
+        assert (
+            count_truncated_rollouts([_inferred({"finish_reasons": ["MAX_TOKENS"]})])
+            == 1
+        )
+
     def test_same_rollout_truncated_on_two_turns_counts_once(self):
         # A multi-turn stage makes several calls per rollout. Rollout 0 hit the
         # cap on both turns; that is one truncated rollout, not two.