adk-code-mode 1.3.0__tar.gz → 1.4.0__tar.gz

adk_code_mode-1.4.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+    ".": "1.4.0"
+}

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.4.0](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.3.0...adk-code-mode-v1.4.0) (2026-07-28)
+
+
+### Features
+
+* surface nested schema properties and validation keywords in tool stubs ([608d14b](https://github.com/a2anet/adk-code-mode/commit/608d14bb115159b2991c7d8d4e3c641977fd0d66))
+
+
+### Documentation
+
+* document stub schema fidelity and the `JSON_SCHEMA_FOR_FUNC_DECL` flag in `README.md` ([219f02b](https://github.com/a2anet/adk-code-mode/commit/219f02bd493c2e2d7275a0034ef2a40db933859f))
+
 ## [1.3.0](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.2.0...adk-code-mode-v1.3.0) (2026-07-23)
 
 

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adk-code-mode
-Version: 1.3.0
+Version: 1.4.0
 Summary: A "Code Mode" sandboxed code-execution tool for ADK agents to interact with tools, files, and custom packages with Python
 Project-URL: Documentation, https://github.com/A2ANet/adk-code-mode#readme
 Project-URL: Issues, https://github.com/A2ANet/adk-code-mode/issues
@@ -377,6 +377,38 @@ Tags are indented; their content is not. The `<tools-package>` body is Python so
 
 With `save_tool_results_as_artifacts` enabled (the default), each non-artifact tool above — e.g. `list_channels` and `send_message` — also carries two optional `artifact_name: str | None = ...` / `artifact_description: str | None = ...` parameters for naming its saved result.
 
+#### Schema fidelity
+
+Stubs are rendered from each tool's declaration, so whatever the declaration drops can never reach the model. Nested object properties, their descriptions and JSON Schema's validation keywords all land in the docstring, because no Python type expresses them:
+
+~~~python
+def create_minimum_spend_rule(*, space_id: int, conditions: dict[str, Any] | None = ..., label: str | None = ...) -> Any:
+    """Creates a new minimum spend rule under the MinimumSpend policy.
+
+    Args:
+        space_id: The unique identifier of the venue space. (format=int32)
+        conditions: Conditions that must all be satisfied for the rule to apply (AND logic).
+            daysOfWeek: list[int] | None - Days of the week (1=Monday, 7=Sunday). (items: minimum=1, maximum=7)
+            timeRange: dict[str, Any] | None - Time window of the booking start time.
+                from: str (pattern=^([01][0-9]|2[0-3]):[0-5][0-9]$, example=18:00)
+                to: str (example=23:59)
+        label: (maxLength=255)
+    """
+~~~
+
+Every JSON Schema 2020-12 Validation and Meta-Data keyword is covered; `tests/test_stubs_json_schema.py` reads the keyword set from the meta-schemas and fails if one goes unclassified.
+
+> [!IMPORTANT]
+> **Enable ADK's `JSON_SCHEMA_FOR_FUNC_DECL` feature to get the full picture.** It is off by default, and without it ADK builds declarations through a Gemini `types.Schema`, which reduces an `allOf`-wrapped `$ref` — how OpenAPI 3.0 spells a nullable reference — to a bare `{"type": "OBJECT"}`. The referenced properties and description are gone before this package sees them, and the field renders as an empty `dict[str, Any]`.
+>
+> ```python
+> from google.adk.features import FeatureName, override_feature_enabled
+>
+> override_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL, True)
+> ```
+>
+> Or set `ADK_ENABLE_JSON_SCHEMA_FOR_FUNC_DECL=1` in the environment. Do this before building any tool. It changes how declarations are built for every tool in the process, so if the same process also exposes tools to the model directly, check the model layer accepts `parameters_json_schema` — ADK's LiteLLM integration does, and `ExecuteCodeTool` declares itself that way regardless.
+
 #### Fitting the budget
 
 A block over `max_code_mode_metadata_chars` degrades in tiers instead of vanishing. The Python version and package list survive every tier — they're small, and the model cannot discover them any other way.

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/README.md

@@ -350,6 +350,38 @@ Tags are indented; their content is not. The `<tools-package>` body is Python so
 
 With `save_tool_results_as_artifacts` enabled (the default), each non-artifact tool above — e.g. `list_channels` and `send_message` — also carries two optional `artifact_name: str | None = ...` / `artifact_description: str | None = ...` parameters for naming its saved result.
 
+#### Schema fidelity
+
+Stubs are rendered from each tool's declaration, so whatever the declaration drops can never reach the model. Nested object properties, their descriptions and JSON Schema's validation keywords all land in the docstring, because no Python type expresses them:
+
+~~~python
+def create_minimum_spend_rule(*, space_id: int, conditions: dict[str, Any] | None = ..., label: str | None = ...) -> Any:
+    """Creates a new minimum spend rule under the MinimumSpend policy.
+
+    Args:
+        space_id: The unique identifier of the venue space. (format=int32)
+        conditions: Conditions that must all be satisfied for the rule to apply (AND logic).
+            daysOfWeek: list[int] | None - Days of the week (1=Monday, 7=Sunday). (items: minimum=1, maximum=7)
+            timeRange: dict[str, Any] | None - Time window of the booking start time.
+                from: str (pattern=^([01][0-9]|2[0-3]):[0-5][0-9]$, example=18:00)
+                to: str (example=23:59)
+        label: (maxLength=255)
+    """
+~~~
+
+Every JSON Schema 2020-12 Validation and Meta-Data keyword is covered; `tests/test_stubs_json_schema.py` reads the keyword set from the meta-schemas and fails if one goes unclassified.
+
+> [!IMPORTANT]
+> **Enable ADK's `JSON_SCHEMA_FOR_FUNC_DECL` feature to get the full picture.** It is off by default, and without it ADK builds declarations through a Gemini `types.Schema`, which reduces an `allOf`-wrapped `$ref` — how OpenAPI 3.0 spells a nullable reference — to a bare `{"type": "OBJECT"}`. The referenced properties and description are gone before this package sees them, and the field renders as an empty `dict[str, Any]`.
+>
+> ```python
+> from google.adk.features import FeatureName, override_feature_enabled
+>
+> override_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL, True)
+> ```
+>
+> Or set `ADK_ENABLE_JSON_SCHEMA_FOR_FUNC_DECL=1` in the environment. Do this before building any tool. It changes how declarations are built for every tool in the process, so if the same process also exposes tools to the model directly, check the model layer accepts `parameters_json_schema` — ADK's LiteLLM integration does, and `ExecuteCodeTool` declares itself that way regardless.
+
 #### Fitting the budget
 
 A block over `max_code_mode_metadata_chars` degrades in tiers instead of vanishing. The Python version and package list survive every tier — they're small, and the model cannot discover them any other way.

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/pyproject.toml

@@ -35,6 +35,9 @@ docker = ["docker>=7.0.0"]
 [dependency-groups]
 dev = [
     "adk-code-mode[docker]",
+    # Ships the JSON Schema 2020-12 meta-schemas, which `test_stubs_json_schema`
+    # reads to enumerate the keyword set rather than hard-coding it.
+    "jsonschema-specifications>=2023.0.0",
     "mypy>=1.19.0",
     "pytest>=8.0.0",
     "pytest-asyncio>=0.23.0",
@@ -69,6 +72,10 @@ ignore_missing_imports = true
 module = ["websockets", "websockets.*"]
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = ["jsonschema_specifications", "jsonschema_specifications.*"]
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src", "sandbox-wheel/src"]

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/sandbox-wheel/src/adk_code_mode_sandbox/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.3.0"  # x-release-please-version
+__version__ = "1.4.0"  # x-release-please-version

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/src/adk_code_mode/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present A2A Net <hello@a2anet.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.3.0"  # x-release-please-version
+__version__ = "1.4.0"  # x-release-please-version

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/src/adk_code_mode/tools/stubs.py

@@ -32,6 +32,64 @@ _PRIMITIVES = {
     "null": "None",
 }
 
+# Gemini `types.Schema` renames JSON Schema's keywords; map them back. A value of
+# `None` drops the key (it carries nothing a caller can act on).
+_KEY_ALIASES: dict[str, str | None] = {
+    "max_length": "maxLength",
+    "min_length": "minLength",
+    "max_items": "maxItems",
+    "min_items": "minItems",
+    "max_properties": "maxProperties",
+    "min_properties": "minProperties",
+    "any_of": "anyOf",
+    "additional_properties": "additionalProperties",
+    "property_ordering": None,
+}
+
+# Validation and annotation keywords worth showing a caller, in the order they
+# read best. These never reach the signature — no Python type expresses
+# `maxLength` — so the docstring is their only route to the model.
+#
+# Deliberately not surfaced: `not`, `if`/`then`/`else`, `dependentSchemas`,
+# `propertyNames`, `unevaluated*` and `contains` (as a schema). They express
+# conditional structure that reads as noise in a one-line summary, and none of
+# them appear in the OpenAPI documents this renders in practice. `$schema`,
+# `$id`, `$anchor`, `$comment` and `$vocabulary` describe the document rather
+# than the value.
+_CONSTRAINTS = (
+    "format",
+    "pattern",
+    "minLength",
+    "maxLength",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "uniqueItems",
+    "minContains",
+    "maxContains",
+    "minProperties",
+    "maxProperties",
+    "contentEncoding",
+    "contentMediaType",
+    "const",
+    "example",
+)
+
+# Boolean annotations that change whether a caller should send a value at all.
+_FLAGS = (
+    ("deprecated", "deprecated"),
+    ("readOnly", "read-only"),
+    ("writeOnly", "write-only"),
+)
+
+# Guards against self-referential schemas, which recurse forever otherwise. Not a
+# size budget: the agent can always read the full stub with `help()`.
+_MAX_SCHEMA_DEPTH = 8
+
 Target = Literal["stub", "catalog"]
 
 
@@ -59,12 +117,65 @@ def _schema_dict_from_declaration(declaration: Any) -> dict[str, Any]:
     return {}
 
 
+def _effective_schema(schema: Any) -> dict[str, Any]:
+    """Normalise a schema fragment to plain JSON Schema and flatten ``allOf``.
+
+    Two shapes reach us. With ADK's ``JSON_SCHEMA_FOR_FUNC_DECL`` feature on,
+    ``parameters_json_schema`` carries untouched JSON Schema. With it off (the
+    default today) ADK converts through a Gemini ``types.Schema``, which
+    upper-cases ``type`` and snake-cases the validation keywords — and drops the
+    body of an ``allOf``-wrapped ``$ref`` entirely, which no amount of work here
+    can recover.
+
+    Merging ``allOf`` matters because ``allOf: [$ref] + nullable: true`` is how
+    OpenAPI 3.0 spells "nullable reference": without the merge the wrapper looks
+    like an empty schema and the target's description and properties are lost.
+    """
+    if not isinstance(schema, dict):
+        return {}
+
+    normalised: dict[str, Any] = {}
+    for key, value in schema.items():
+        canonical = _KEY_ALIASES.get(key, key)
+        if canonical is None or value is None:
+            continue
+        normalised.setdefault(canonical, value)
+
+    ty = normalised.get("type")
+    if isinstance(ty, str):
+        normalised["type"] = ty.lower()
+    elif isinstance(ty, list):
+        normalised["type"] = [t.lower() if isinstance(t, str) else t for t in ty]
+
+    variants = normalised.pop("allOf", None)
+    if isinstance(variants, list):
+        merged: dict[str, Any] = {}
+        for part in variants:
+            merged.update(_effective_schema(part))
+        # The wrapper's own keys win: `nullable` sits beside the `$ref`, not in it.
+        merged.update(normalised)
+        normalised = merged
+
+    # A one-variant union expresses no choice, so fold it in rather than lose
+    # the description and properties hanging off the single branch.
+    for key in ("anyOf", "oneOf"):
+        branches = normalised.get(key)
+        if isinstance(branches, list) and len(branches) == 1:
+            folded = _effective_schema(branches[0])
+            normalised.pop(key)
+            folded.update(normalised)
+            normalised = folded
+
+    return normalised
+
+
 def _schema_to_type(schema: Any) -> str:
     """Convert a JSON-Schema fragment to a Python type expression (PEP 604).
 
     Best-effort. Anything we can't resolve cleanly falls back to ``Any``.
     """
-    if not isinstance(schema, dict):
+    schema = _effective_schema(schema)
+    if not schema:
         return "Any"
 
     # Compositions.
@@ -77,14 +188,6 @@ def _schema_to_type(schema: Any) -> str:
         if len(parts) == 1:
             return parts[0]
         return " | ".join(parts)
-    if "allOf" in schema:
-        merged: dict[str, Any] = {}
-        for part in schema["allOf"]:
-            if isinstance(part, dict):
-                merged.update(part)
-        if merged:
-            return _schema_to_type(merged)
-        return "Any"
 
     if "enum" in schema and schema["enum"]:
         lits: list[str] = []
@@ -128,7 +231,14 @@ def _schema_to_type(schema: Any) -> str:
         else:
             result = "list[Any]"
     elif ty == "object":
-        result = "dict[str, Any]"
+        # An open map (`additionalProperties` as a schema, no fixed properties)
+        # types precisely; anything with declared keys stays `dict[str, Any]`
+        # and gets its shape from the docstring instead.
+        extra = schema.get("additionalProperties")
+        if isinstance(extra, dict) and not schema.get("properties"):
+            result = f"dict[str, {_schema_to_type(extra)}]"
+        else:
+            result = "dict[str, Any]"
     elif isinstance(ty, str) and ty in _PRIMITIVES:
         result = _PRIMITIVES[ty]
     else:
@@ -149,21 +259,120 @@ def _python_default(schema: dict[str, Any]) -> str | None:
         return None
 
 
-def _format_docstring(*, description: str, param_docs: list[tuple[str, str, str | None]]) -> str:
+def _format_scalar(value: Any) -> str:
+    """Render a schema value compactly. Gemini widens integers to floats."""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, float) and value.is_integer():
+        return str(int(value))
+    if isinstance(value, str):
+        return value
+    return str(value)
+
+
+def _constraint_suffix(schema: dict[str, Any], *, include_default: bool = False) -> str:
+    """Render a schema's validation keywords as ``(minimum=1, maximum=7)``.
+
+    Array constraints living on ``items`` are folded in under an ``items:``
+    prefix, so ``daysOfWeek`` shows its 1-7 bound rather than hiding it a level
+    down where the type expression has already collapsed to ``list[int]``.
+    """
+    parts = [f"{key}={_format_scalar(schema[key])}" for key in _CONSTRAINTS if key in schema]
+    examples = schema.get("examples")
+    if isinstance(examples, list) and examples:
+        parts.append("examples=" + ", ".join(_format_scalar(v) for v in examples[:2]))
+    if include_default and "default" in schema:
+        parts.append(f"default={_format_scalar(schema['default'])}")
+    parts.extend(label for key, label in _FLAGS if schema.get(key) is True)
+    if schema.get("additionalProperties") is False:
+        parts.append("no other keys")
+    dependent = schema.get("dependentRequired")
+    if isinstance(dependent, dict):
+        parts.extend(
+            f"{name} requires {', '.join(needed)}" for name, needed in dependent.items() if needed
+        )
+    pattern_properties = schema.get("patternProperties")
+    if isinstance(pattern_properties, dict) and pattern_properties:
+        parts.append("key patterns: " + ", ".join(pattern_properties))
+
+    items = schema.get("items")
+    if isinstance(items, dict):
+        item_schema = _effective_schema(items)
+        item_parts = [
+            f"{key}={_format_scalar(item_schema[key])}"
+            for key in _CONSTRAINTS
+            if key in item_schema
+        ]
+        if item_parts:
+            parts.append("items: " + ", ".join(item_parts))
+
+    return f" ({', '.join(parts)})" if parts else ""
+
+
+def _prose(schema: dict[str, Any]) -> str:
+    """The schema's human text: ``description``, else ``title``.
+
+    Plenty of real schemas carry only a ``title``; dropping it would leave the
+    field with a type and nothing else.
+    """
+    for key in ("description", "title"):
+        text = str(schema.get(key, "")).strip()
+        if text:
+            return text
+    return ""
+
+
+def _describe_fields(schema: dict[str, Any], *, indent: str, depth: int = 0) -> list[str]:
+    """Lines describing an object's properties, recursing into nested schemas.
+
+    The signature can only ever say ``dict[str, Any]`` for an object, so without
+    this the key names, their types and their meanings never reach the model.
+    """
+    if depth >= _MAX_SCHEMA_DEPTH:
+        return []
+
+    properties = schema.get("properties")
+    if not isinstance(properties, dict) or not properties:
+        items = schema.get("items")
+        if isinstance(items, dict):
+            return _describe_fields(_effective_schema(items), indent=indent, depth=depth + 1)
+        return []
+
+    required = set(schema.get("required") or [])
+    lines: list[str] = []
+    for name, raw in properties.items():
+        field = _effective_schema(raw)
+        head = f"{indent}{name}: {_schema_to_type(field)}"
+        if name in required:
+            head += " (required)"
+        description = _prose(field).splitlines()
+        if description:
+            head += f" - {description[0].strip()}"
+        lines.append(head + _constraint_suffix(field, include_default=True))
+        for extra in description[1:]:
+            lines.append(f"{indent}    {extra.strip()}")
+        lines.extend(_describe_fields(field, indent=indent + "    ", depth=depth + 1))
+    return lines
+
+
+def _format_docstring(
+    *, description: str, param_docs: list[tuple[str, dict[str, Any], str | None]]
+) -> str:
     lines: list[str] = []
     summary = (description or "").strip() or "Call the tool."
     lines.extend(textwrap.wrap(summary, width=88) or [summary])
     if param_docs:
         lines.append("")
         lines.append("Args:")
-        for name, desc, default_repr in param_docs:
-            desc = (desc or "").strip()
+        for name, schema, default_repr in param_docs:
+            desc = _prose(schema)
             first, *rest = (desc or "").splitlines() or [""]
             suffix = f" (default: {default_repr})" if default_repr is not None else ""
-            head = first + suffix
+            head = (first + _constraint_suffix(schema) + suffix).strip()
             lines.append(f"    {name}: {head}" if head else f"    {name}:")
             for extra in rest:
                 lines.append(f"        {extra}")
+            lines.extend(_describe_fields(schema, indent="        "))
     body = "\n    ".join(lines)
     return f'"""{body}\n    """'
 
@@ -279,7 +488,7 @@ def render_tool(nt: NamespacedTool) -> RenderedTool:
     ordered = sorted(props.items(), key=lambda kv: (kv[0] not in required, kv[0]))
 
     params: list[RenderedParam] = []
-    param_docs: list[tuple[str, str, str | None]] = []
+    param_docs: list[tuple[str, dict[str, Any], str | None]] = []
 
     seen_param_names: dict[str, str] = {}
 
@@ -293,7 +502,7 @@ def render_tool(nt: NamespacedTool) -> RenderedTool:
                 "of the tool parameters so the generated stub signature is unambiguous."
             )
         seen_param_names[py_name] = raw_name
-        subschema = subschema if isinstance(subschema, dict) else {}
+        subschema = _effective_schema(subschema)
         type_expr = _schema_to_type(subschema)
         default = _python_default(subschema)
         is_required = raw_name in required
@@ -307,7 +516,7 @@ def render_tool(nt: NamespacedTool) -> RenderedTool:
             )
         )
         doc_default = default if (not is_required and default is not None) else None
-        param_docs.append((py_name, str(subschema.get("description", "")), doc_default))
+        param_docs.append((py_name, subschema, doc_default))
 
     description = ""
     if declaration is not None and declaration.description:

{adk_code_mode-1.3.0 → adk_code_mode-1.4.0}/tests/test_stubs.py

@@ -252,3 +252,136 @@ def test_rendered_tool_catalog_signature_uses_ellipsis() -> None:
     sig = rt.signature_for("catalog")
     assert "include_archived: bool | None = ..." in sig
     assert "_MISSING" not in sig
+
+
+def test_render_tool_expands_nested_object_properties() -> None:
+    """An object parameter can only ever be typed ``dict[str, Any]``, so its keys
+    reach the model through the docstring or not at all."""
+    tool = _SchemaTool(
+        "create_rule",
+        description="Create a rule.",
+        schema={
+            "type": "object",
+            "properties": {
+                "conditions": {
+                    "type": "object",
+                    "description": "Conditions that must all be satisfied (AND logic).",
+                    "properties": {
+                        "daysOfWeek": {
+                            "type": "array",
+                            "description": "Days of the week (1=Monday, 7=Sunday).",
+                            "items": {"type": "integer", "minimum": 1, "maximum": 7},
+                        },
+                        "timeRange": {
+                            "type": "object",
+                            "properties": {
+                                "from": {"type": "string", "example": "18:00"},
+                                "to": {"type": "string"},
+                            },
+                        },
+                    },
+                }
+            },
+        },
+    )
+    ns = _build([(tool, None)])
+    source = _stub_source(ns[0])
+    assert "conditions: dict[str, Any] | None" in source
+    assert "daysOfWeek: list[int] - Days of the week (1=Monday, 7=Sunday)." in source
+    assert "items: minimum=1, maximum=7" in source
+    assert "timeRange: dict[str, Any]" in source
+    assert "from: str (example=18:00)" in source
+    assert "to: str" in source
+
+
+def test_render_tool_documents_validation_keywords() -> None:
+    """No Python type expresses ``maxLength``/``pattern``; the docstring is the
+    only route by which they reach the model."""
+    tool = _SchemaTool(
+        "save",
+        description="Save.",
+        schema={
+            "type": "object",
+            "properties": {
+                "label": {"type": "string", "maxLength": 255},
+                "code": {"type": "string", "pattern": "^[A-Z]{3}$"},
+                "ratio": {"type": "number", "minimum": 0, "maximum": 1},
+                "tags": {"type": "array", "minItems": 1, "items": {"type": "string"}},
+            },
+        },
+    )
+    ns = _build([(tool, None)])
+    source = _stub_source(ns[0])
+    assert "label: (maxLength=255)" in source
+    assert "code: (pattern=^[A-Z]{3}$)" in source
+    assert "ratio: (minimum=0, maximum=1)" in source
+    assert "tags: (minItems=1)" in source
+
+
+def test_render_tool_merges_allof_wrapped_ref() -> None:
+    """``allOf: [$ref] + nullable`` is how OpenAPI 3.0 spells a nullable
+    reference; without merging, the target's description and keys are lost."""
+    tool = _SchemaTool(
+        "book",
+        description="Book.",
+        schema={
+            "type": "object",
+            "properties": {
+                "capacity": {
+                    "allOf": [
+                        {
+                            "type": "object",
+                            "description": "Min/max capacity range.",
+                            "properties": {
+                                "min": {"type": "integer"},
+                                "max": {"type": "integer"},
+                            },
+                        }
+                    ],
+                    "nullable": True,
+                }
+            },
+        },
+    )
+    ns = _build([(tool, None)])
+    source = _stub_source(ns[0])
+    assert "capacity: Min/max capacity range." in source
+    assert "min: int" in source
+    assert "max: int" in source
+
+
+def test_render_tool_normalises_gemini_schema_casing() -> None:
+    """With ADK's ``JSON_SCHEMA_FOR_FUNC_DECL`` off, schemas arrive via a Gemini
+    ``types.Schema``: upper-cased types and snake_cased keywords."""
+    tool = _SchemaTool(
+        "gemini_shaped",
+        description="Gemini shaped.",
+        schema={
+            "type": "OBJECT",
+            "properties": {
+                "label": {"type": "STRING", "max_length": 255},
+                "nested": {
+                    "type": "OBJECT",
+                    "properties": {"count": {"type": "INTEGER", "minimum": 1.0}},
+                },
+            },
+        },
+    )
+    ns = _build([(tool, None)])
+    source = _stub_source(ns[0])
+    assert "label: str | None" in source
+    assert "maxLength=255" in source
+    assert "count: int (minimum=1)" in source
+
+
+def test_render_tool_stops_recursing_on_self_referential_schema() -> None:
+    """A schema that contains itself must not recurse forever."""
+    node: dict[str, object] = {"type": "object", "description": "A tree node."}
+    node["properties"] = {"child": node}
+    tool = _SchemaTool(
+        "walk", description="Walk.", schema={"type": "object", "properties": {"root": node}}
+    )
+    ns = _build([(tool, None)])
+    source = _stub_source(ns[0])
+    assert "root: A tree node." in source
+    assert source.count("child: dict[str, Any]") == stubs._MAX_SCHEMA_DEPTH