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

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

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

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

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.6.0](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.5.0...adk-code-mode-v1.6.0) (2026-08-29)
+
+
+### Features
+
+* bound an execute_code block by default ([1609c0d](https://github.com/a2anet/adk-code-mode/commit/1609c0d24b8563cba51434cd1214b4299aeefc86))
+* expand object oneOf/anyOf branches in tool stub docstrings ([#20](https://github.com/a2anet/adk-code-mode/issues/20)) ([7d42cb1](https://github.com/a2anet/adk-code-mode/commit/7d42cb1ee9d9e217d008776dc74a84034f4b67a9))
+
+## [1.5.0](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.4.0...adk-code-mode-v1.5.0) (2026-08-10)
+
+
+### Features
+
+* scope tool-name uniqueness to each namespace ([#17](https://github.com/a2anet/adk-code-mode/issues/17)) ([437bc0d](https://github.com/a2anet/adk-code-mode/commit/437bc0dc930521a933e5c25b4bd6103e9434fc27))
+
 ## [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)
 
 

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: adk-code-mode
-Version: 1.4.0
+Version: 1.6.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
@@ -85,13 +85,17 @@ Build an `ExecuteCodeTool`, give it the tools the sandboxed code may call, and a
 
 ```python
 from google.adk.agents import LlmAgent
+from google.adk.features import FeatureName, override_feature_enabled
 from adk_code_mode import ExecuteCodeTool, RemoteBackend
 
+# Required for docstrings to show full tool schemas
+override_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL, True)
+
 tool = ExecuteCodeTool(
     tools=[my_fn_tool, McpToolset(...), OpenAPIToolset(...)],
     backend=RemoteBackend(
-        url="https://sandbox-xyz.run.app",  # your deployed sandbox URL
-        token="your-secret-token",           # bearer token for auth
+        url="https://sandbox-xyz.run.app",
+        token="your-secret-token",
     ),
 )
 
@@ -112,8 +116,12 @@ root_agent = LlmAgent(
 > **`UnsafeLocalDockerBackend` is not safe for production or multi-tenant use.** See [Safety](#-safety).
 
 ```python
+from google.adk.features import FeatureName, override_feature_enabled
 from adk_code_mode import ExecuteCodeTool, UnsafeLocalDockerBackend
 
+# Required for docstrings to show full tool schemas
+override_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL, True)
+
 tool = ExecuteCodeTool(
     tools=[my_fn_tool, McpToolset(...), OpenAPIToolset(...)],
     backend=UnsafeLocalDockerBackend(image="ghcr.io/a2anet/adk-code-mode:latest"),
@@ -292,7 +300,7 @@ All settings are `ExecuteCodeTool` constructor arguments:
 | `max_code_mode_metadata_chars` | `50_000` | Budget for the whole rendered `<code-mode>` block, tags included. Oversized blocks degrade in tiers rather than disappearing — see [What the model sees](#what-the-model-sees). |
 | `max_output_chars` | `50_000` | Caps stdout/stderr handed back to the model. Overflow is saved as a session artifact at `code_mode/stdout/<call-id>.txt` and the model sees a head-and-tail view pointing to it. |
 | `max_code_chars` | `1_000_000` | Rejects oversized code payloads before starting a container. |
-| `timeout_seconds` | `None` | Caps overall execution time of one `execute_code` call. Defaults to the platform request timeout (e.g. Cloud Run `--timeout`); set explicitly for defense in depth. |
+| `timeout_seconds` | `60` | Caps overall execution time of one `execute_code` call, and with it every tool the block calls. `None` lifts the cap, leaving the platform request timeout (e.g. Cloud Run `--timeout`) as the only bound. |
 | `per_tool_timeout_seconds` | `None` | Caps each individual tool call made from within the sandbox. |
 | `session_idle_timeout_seconds` | `600` | Idle reaper: closes a turn's container once it goes untouched this long. Backstop for turns that never call `release_invocation`. |
 
@@ -377,38 +385,6 @@ 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.4.0 → adk_code_mode-1.6.0}/README.md

@@ -58,13 +58,17 @@ Build an `ExecuteCodeTool`, give it the tools the sandboxed code may call, and a
 
 ```python
 from google.adk.agents import LlmAgent
+from google.adk.features import FeatureName, override_feature_enabled
 from adk_code_mode import ExecuteCodeTool, RemoteBackend
 
+# Required for docstrings to show full tool schemas
+override_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL, True)
+
 tool = ExecuteCodeTool(
     tools=[my_fn_tool, McpToolset(...), OpenAPIToolset(...)],
     backend=RemoteBackend(
-        url="https://sandbox-xyz.run.app",  # your deployed sandbox URL
-        token="your-secret-token",           # bearer token for auth
+        url="https://sandbox-xyz.run.app",
+        token="your-secret-token",
     ),
 )
 
@@ -85,8 +89,12 @@ root_agent = LlmAgent(
 > **`UnsafeLocalDockerBackend` is not safe for production or multi-tenant use.** See [Safety](#-safety).
 
 ```python
+from google.adk.features import FeatureName, override_feature_enabled
 from adk_code_mode import ExecuteCodeTool, UnsafeLocalDockerBackend
 
+# Required for docstrings to show full tool schemas
+override_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL, True)
+
 tool = ExecuteCodeTool(
     tools=[my_fn_tool, McpToolset(...), OpenAPIToolset(...)],
     backend=UnsafeLocalDockerBackend(image="ghcr.io/a2anet/adk-code-mode:latest"),
@@ -265,7 +273,7 @@ All settings are `ExecuteCodeTool` constructor arguments:
 | `max_code_mode_metadata_chars` | `50_000` | Budget for the whole rendered `<code-mode>` block, tags included. Oversized blocks degrade in tiers rather than disappearing — see [What the model sees](#what-the-model-sees). |
 | `max_output_chars` | `50_000` | Caps stdout/stderr handed back to the model. Overflow is saved as a session artifact at `code_mode/stdout/<call-id>.txt` and the model sees a head-and-tail view pointing to it. |
 | `max_code_chars` | `1_000_000` | Rejects oversized code payloads before starting a container. |
-| `timeout_seconds` | `None` | Caps overall execution time of one `execute_code` call. Defaults to the platform request timeout (e.g. Cloud Run `--timeout`); set explicitly for defense in depth. |
+| `timeout_seconds` | `60` | Caps overall execution time of one `execute_code` call, and with it every tool the block calls. `None` lifts the cap, leaving the platform request timeout (e.g. Cloud Run `--timeout`) as the only bound. |
 | `per_tool_timeout_seconds` | `None` | Caps each individual tool call made from within the sandbox. |
 | `session_idle_timeout_seconds` | `600` | Idle reaper: closes a turn's container once it goes untouched this long. Backstop for turns that never call `release_invocation`. |
 
@@ -350,38 +358,6 @@ 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.4.0 → adk_code_mode-1.6.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.4.0"  # x-release-please-version
+__version__ = "1.6.0"  # x-release-please-version

{adk_code_mode-1.4.0 → adk_code_mode-1.6.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.4.0"  # x-release-please-version
+__version__ = "1.6.0"  # x-release-please-version

{adk_code_mode-1.4.0 → adk_code_mode-1.6.0}/src/adk_code_mode/tool.py

@@ -97,6 +97,11 @@ class _BlockConnectionLost(Exception):
 
 logger = logging.getLogger("adk_code_mode.tool")
 
+# A block is a model-authored program, so it is bounded by default: an unbounded one
+# strands its container (the idle reaper skips turns still in use) and holds up
+# whatever is waiting on the turn. Hosts that genuinely need longer pass their own.
+DEFAULT_TIMEOUT_SECONDS = 60
+
 _REAPER_MAX_POLL_SECONDS = 30.0
 
 # One block runs at most twice: the original attempt plus a single reconnect, and
@@ -202,7 +207,7 @@ class ExecuteCodeTool(BaseTool):
         max_code_mode_metadata_chars: int = 50_000,
         max_output_chars: int = 50_000,
         max_code_chars: int = 1_000_000,
-        timeout_seconds: int | None = None,
+        timeout_seconds: int | None = DEFAULT_TIMEOUT_SECONDS,
         per_tool_timeout_seconds: float | None = None,
         session_idle_timeout_seconds: float = 600,
         on_artifacts_saved: ArtifactsSavedCallback | None = None,
@@ -241,7 +246,9 @@ class ExecuteCodeTool(BaseTool):
           max_code_chars: Rejects oversized code payloads before starting a
             container.
           timeout_seconds: Caps overall execution time of one ``execute_code``
-            call.
+            call, and with it every tool the block calls. ``None`` lifts the cap,
+            which leaves a runaway block stranding its container until the idle
+            reaper takes it.
           per_tool_timeout_seconds: Caps each individual tool call made from
             within the sandbox.
           session_idle_timeout_seconds: Idle reaper: closes a turn's container

{adk_code_mode-1.4.0 → adk_code_mode-1.6.0}/src/adk_code_mode/tools/namespacing.py

@@ -26,7 +26,7 @@ class ToolSurfaceError(ValueError):
 
 
 class DuplicateToolNameError(ToolSurfaceError):
-    """Raised when two resolved tools share the same raw ADK tool name."""
+    """Raised when two tools in the same namespace share a raw ADK tool name."""
 
 
 class NamespaceCollisionError(ToolSurfaceError):
@@ -91,23 +91,22 @@ def build(tools: list[ResolvedTool]) -> list[NamespacedTool]:
     """
     out: list[NamespacedTool] = []
     seen_attributes: set[tuple[str | None, str]] = set()
-    seen_raw_names: dict[str, NamespacedTool] = {}
+    seen_raw_names: dict[tuple[str | None, str], NamespacedTool] = {}
     namespace_sources: dict[str, BaseToolset] = {}
     bare_attributes: dict[str, NamespacedTool] = {}
     for resolved in tools:
         namespace = _toolset_namespace(resolved.toolset) if resolved.toolset else None
-        if resolved.tool.name in seen_raw_names:
-            other = seen_raw_names[resolved.tool.name]
-            candidate = (
-                f"{namespace}.{_sanitise_identifier(resolved.tool.name, fallback='tool')}"
-                if namespace
-                else _sanitise_identifier(resolved.tool.name, fallback="tool")
-            )
+        # Raw names only have to be unique *within* a namespace: dispatch goes
+        # through the dotted path, so two toolsets may each expose ``list_items``.
+        raw_key = (namespace, resolved.tool.name)
+        if raw_key in seen_raw_names:
+            other = seen_raw_names[raw_key]
             raise DuplicateToolNameError(
-                f"Duplicate ADK tool name {resolved.tool.name!r} is not supported; this would "
-                f"make host dispatch ambiguous between {other.dotted_path!r} (from "
-                f"{_origin(other.resolved)}) and {candidate!r} (from {_origin(resolved)}). "
-                "Rename one of the tools or apply distinct ``tool_name_prefix`` values."
+                f"Duplicate ADK tool name {resolved.tool.name!r} within namespace "
+                f"{namespace or 'tools'!r} is not supported; this would make host dispatch "
+                f"ambiguous for {other.dotted_path!r} (from {_origin(other.resolved)} and "
+                f"{_origin(resolved)}). Rename one of the tools or apply distinct "
+                "``tool_name_prefix`` values."
             )
         if namespace is not None and resolved.toolset is not None:
             existing_source = namespace_sources.get(namespace)
@@ -138,7 +137,7 @@ def build(tools: list[ResolvedTool]) -> list[NamespacedTool]:
             )
         seen_attributes.add(key)
         nt = NamespacedTool(resolved=resolved, namespace=namespace, attribute=attribute)
-        seen_raw_names[resolved.tool.name] = nt
+        seen_raw_names[raw_key] = nt
         if namespace is None:
             bare_attributes[attribute] = nt
         out.append(nt)
@@ -167,15 +166,12 @@ class Registry:
 
     def __init__(self, tools: list[NamespacedTool]) -> None:
         self._by_path: dict[str, NamespacedTool] = {t.dotted_path: t for t in tools}
-        by_tool_name: dict[str, NamespacedTool] = {}
+        # Generated stubs call ``_call(<dotted path>, ...)``, so this map is only a
+        # fallback for callers that know the raw ADK name. A name shared by two
+        # namespaces is ambiguous and simply doesn't resolve through it.
+        by_tool_name: dict[str, NamespacedTool | None] = {}
         for tool in tools:
-            existing = by_tool_name.get(tool.tool_name)
-            if existing is not None:
-                raise DuplicateToolNameError(
-                    "Duplicate ADK tool name "
-                    f"{tool.tool_name!r} is not supported; use unique tool names."
-                )
-            by_tool_name[tool.tool_name] = tool
+            by_tool_name[tool.tool_name] = None if tool.tool_name in by_tool_name else tool
         self._by_tool_name = by_tool_name
         self._tools = list(tools)
 
@@ -187,10 +183,11 @@ class Registry:
         return self._by_path.get(path)
 
     def by_tool_name(self, tool_name: str) -> NamespacedTool | None:
+        """Resolve a raw ADK name, or ``None`` if unknown or shared by two namespaces."""
         return self._by_tool_name.get(tool_name)
 
     def resolve_call(self, name: str) -> NamespacedTool:
-        """Accept either the dotted path or the original ``BaseTool.name``."""
+        """Accept either the dotted path or an unambiguous original ``BaseTool.name``."""
         hit = self._by_path.get(name) or self._by_tool_name.get(name)
         if hit is None:
             raise KeyError(f"no tool registered for {name!r}")

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

@@ -151,10 +151,9 @@ def _effective_schema(schema: Any) -> dict[str, Any]:
     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
+            merged = _merge_schema(merged, _effective_schema(part))
+        # Wrapper keys (e.g. `nullable`) win; `properties` / `required` still merge.
+        normalised = _merge_schema(merged, normalised)
 
     # A one-variant union expresses no choice, so fold it in rather than lose
     # the description and properties hanging off the single branch.
@@ -163,12 +162,42 @@ def _effective_schema(schema: Any) -> dict[str, Any]:
         if isinstance(branches, list) and len(branches) == 1:
             folded = _effective_schema(branches[0])
             normalised.pop(key)
-            folded.update(normalised)
-            normalised = folded
+            normalised = _merge_schema(folded, normalised)
 
     return normalised
 
 
+def _merge_schema(base: dict[str, Any], extra: dict[str, Any]) -> dict[str, Any]:
+    """Combine two schemas the way ``allOf`` means: properties accumulate.
+
+    A shallow ``update`` replaces the whole ``properties`` dict, so OpenAPI 3.0
+    ``allOf: [$ref, {properties: extra}]`` would keep only ``extra``.
+    """
+    out = dict(base)
+    extra_props = extra.get("properties")
+    if isinstance(extra_props, dict):
+        props = dict(out.get("properties") or {})
+        for name, schema in extra_props.items():
+            existing = props.get(name)
+            if isinstance(existing, dict) and isinstance(schema, dict):
+                props[name] = _merge_schema(existing, schema)
+            else:
+                props[name] = schema
+        out["properties"] = props
+    extra_required = extra.get("required")
+    if isinstance(extra_required, list):
+        required = [name for name in (out.get("required") or []) if isinstance(name, str)]
+        for name in extra_required:
+            if isinstance(name, str) and name not in required:
+                required.append(name)
+        out["required"] = required
+    for key, value in extra.items():
+        if key in ("properties", "required"):
+            continue
+        out[key] = value
+    return out
+
+
 def _schema_to_type(schema: Any) -> str:
     """Convert a JSON-Schema fragment to a Python type expression (PEP 604).
 
@@ -322,23 +351,93 @@ def _prose(schema: dict[str, Any]) -> str:
     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.
+def _const_or_single_enum(schema: dict[str, Any]) -> str | None:
+    """A branch tag value: ``const`` or a one-element ``enum``."""
+    if "const" in schema:
+        return _format_scalar(schema["const"])
+    enum = schema.get("enum")
+    if isinstance(enum, list) and len(enum) == 1:
+        return _format_scalar(enum[0])
+    return None
 
-    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.
+
+def _union_branch_tag(branch: dict[str, Any], *, discriminator: str | None) -> str | None:
+    """Label a union branch without implying a nested object key.
+
+    OpenAPI discriminator unions (``type: openapi | mcp``) often lose
+    ``discriminator`` once ADK inlines ``$ref`` into ``items``, leaving only a
+    single-value ``type`` enum on each object. Tag as ``(type=openapi)`` rather
+    than a fake ``openapi:`` key the model might nest under.
     """
-    if depth >= _MAX_SCHEMA_DEPTH:
-        return []
+    props = branch.get("properties")
+    if not isinstance(props, dict):
+        return None
+    names: list[str] = []
+    if discriminator:
+        names.append(discriminator)
+    if "type" not in names:
+        names.append("type")
+    for name in names:
+        raw = props.get(name)
+        if not isinstance(raw, dict):
+            continue
+        value = _const_or_single_enum(_effective_schema(raw))
+        if value is not None:
+            return f"{name}={value}"
+    return None
 
+
+def _describe_union(
+    schema: dict[str, Any], variants: list[Any], *, indent: str, depth: int
+) -> list[str]:
+    """Expand object ``oneOf``/``anyOf`` branches into the docstring.
+
+    The signature collapses every object variant to ``dict[str, Any]``, so
+    without this the keys on a discriminator union never reach the model.
+    Primitive-only unions stay in the type expression and are skipped here.
+    """
+    disc = schema.get("discriminator")
+    discriminator = None
+    if isinstance(disc, dict):
+        name = disc.get("propertyName")
+        if isinstance(name, str) and name:
+            discriminator = name
+
+    parent_required = schema.get("required")
+    lines: list[str] = []
+    for raw in variants:
+        branch = _effective_schema(raw)
+        if isinstance(parent_required, list):
+            branch = _merge_schema(branch, {"required": parent_required})
+        nested = _describe_fields(branch, indent=indent, depth=depth + 1)
+        if not nested:
+            continue
+        if lines:
+            lines.append(f"{indent}-- or --")
+        tag = _union_branch_tag(branch, discriminator=discriminator)
+        description = _prose(branch).splitlines()
+        suffix = _constraint_suffix(branch)
+        if tag:
+            head = f"{indent}({tag})"
+            if description:
+                head += f" - {description[0].strip()}"
+            lines.append(head + suffix)
+        elif description:
+            lines.append(f"{indent}{description[0].strip()}{suffix}")
+        elif suffix:
+            lines.append(f"{indent}{suffix.strip()}")
+        for extra in description[1:]:
+            lines.append(f"{indent}    {extra.strip()}")
+        lines.extend(nested)
+    return lines
+
+
+def _describe_properties(schema: dict[str, Any], *, indent: str, depth: int) -> list[str]:
+    """One line per object property, plus nested expansion."""
     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 [])
+    required = {name for name in (schema.get("required") or []) if isinstance(name, str)}
     lines: list[str] = []
     for name, raw in properties.items():
         field = _effective_schema(raw)
@@ -355,6 +454,63 @@ def _describe_fields(schema: dict[str, Any], *, indent: str, depth: int = 0) ->
     return lines
 
 
+def _describe_prefix_items(schema: dict[str, Any], *, indent: str, depth: int) -> list[str]:
+    """Expand object (or union) slots of a ``prefixItems`` tuple.
+
+    Primitive slots are already in the ``tuple[...]`` type expression.
+    """
+    prefix_items = schema.get("prefixItems")
+    if not isinstance(prefix_items, list) or not prefix_items:
+        return []
+    lines: list[str] = []
+    for index, raw in enumerate(prefix_items):
+        field = _effective_schema(raw)
+        nested = _describe_fields(field, indent=indent + "    ", depth=depth + 1)
+        if not nested:
+            continue
+        head = f"{indent}[{index}]: {_schema_to_type(field)}"
+        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(nested)
+    return lines
+
+
+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.
+    Multi-branch ``oneOf``/``anyOf`` is walked the same way: a single-branch
+    union is folded in ``_effective_schema``, but two object variants have no
+    ``properties`` at the union itself. Shared parent ``properties`` are listed
+    first, then the branches.
+    """
+    if depth >= _MAX_SCHEMA_DEPTH:
+        return []
+
+    schema = _effective_schema(schema)
+
+    variants = schema.get("anyOf") or schema.get("oneOf")
+    lines = _describe_properties(schema, indent=indent, depth=depth)
+    if isinstance(variants, list) and len(variants) > 1:
+        lines.extend(_describe_union(schema, variants, indent=indent, depth=depth))
+    if lines:
+        return lines
+
+    prefix_lines = _describe_prefix_items(schema, indent=indent, depth=depth)
+    if prefix_lines:
+        return prefix_lines
+
+    items = schema.get("items")
+    if isinstance(items, dict):
+        return _describe_fields(items, indent=indent, depth=depth + 1)
+    return lines
+
+
 def _format_docstring(
     *, description: str, param_docs: list[tuple[str, dict[str, Any], str | None]]
 ) -> str:

{adk_code_mode-1.4.0 → adk_code_mode-1.6.0}/tests/test_catalog.py

@@ -83,6 +83,18 @@ def test_render_catalog_includes_top_level_tools_section() -> None:
     assert "def echo(*, message: str) -> Any:" in catalog
 
 
+def test_render_catalog_keeps_a_shared_tool_name_in_both_namespaces() -> None:
+    bookings = _FakeToolset("bookings")
+    inventory = _FakeToolset("inventory")
+    a = _SchemaTool("list_items", description="List bookings.", schema={"type": "object"})
+    b = _SchemaTool("list_items", description="List inventory.", schema={"type": "object"})
+    catalog = render_catalog(_build([(a, bookings), (b, inventory)]))
+    assert "from tools.bookings import list_items" in catalog
+    assert "from tools.inventory import list_items" in catalog
+    assert '"""List bookings.' in catalog
+    assert '"""List inventory.' in catalog
+
+
 def test_render_catalog_groups_tools_by_namespace_and_sorts() -> None:
     slack = _FakeToolset("slack")
     gmail = _FakeToolset("gmail")

{adk_code_mode-1.4.0 → adk_code_mode-1.6.0}/tests/test_integration.py

@@ -24,7 +24,11 @@ from google.genai import types as genai_types
 
 from adk_code_mode.runtime.base import SandboxConnectionError, SandboxResult, SandboxSession
 from adk_code_mode.runtime.protocol import PROTOCOL_VERSION, DoneFrame, Frame, ReadyFrame
-from adk_code_mode.tool import ExecuteCodeTool, ProtocolVersionMismatchError
+from adk_code_mode.tool import (
+    DEFAULT_TIMEOUT_SECONDS,
+    ExecuteCodeTool,
+    ProtocolVersionMismatchError,
+)
 
 from ._fake_runtime import FakeRuntime
 
@@ -362,6 +366,11 @@ async def test_timeout_terminates_hung_sandbox() -> None:
     assert "Execution exceeded timeout of 1s" in result["stderr"]
 
 
+def test_a_block_is_bounded_without_the_host_saying_so() -> None:
+    tool = ExecuteCodeTool(tools=[], backend=FakeRuntime())
+    assert tool.timeout_seconds == DEFAULT_TIMEOUT_SECONDS
+
+
 @pytest.mark.asyncio
 async def test_timeout_does_not_wait_for_in_flight_tool_call() -> None:
     artifact_service = InMemoryArtifactService()

{adk_code_mode-1.4.0 → adk_code_mode-1.6.0}/tests/test_namespacing.py

@@ -54,15 +54,46 @@ def test_toolset_tools_share_namespace() -> None:
     assert ns[1].dotted_path == "slack.list_channels"
 
 
-def test_duplicate_raw_tool_names_raise() -> None:
+def test_duplicate_raw_tool_names_in_one_namespace_raise() -> None:
+    slack = _NamedToolset("Slack")
+    tools = [
+        ResolvedTool(tool=_Tool("ping"), toolset=slack),
+        ResolvedTool(tool=_Tool("ping"), toolset=slack),
+    ]
+    with pytest.raises(namespacing.DuplicateToolNameError):
+        namespacing.build(tools)
+
+
+def test_duplicate_bare_tool_names_raise() -> None:
     tools = [
         ResolvedTool(tool=_Tool("ping"), toolset=None),
-        ResolvedTool(tool=_Tool("ping"), toolset=_NamedToolset("Slack")),
+        ResolvedTool(tool=_Tool("ping"), toolset=None),
     ]
     with pytest.raises(namespacing.DuplicateToolNameError):
         namespacing.build(tools)
 
 
+def test_same_tool_name_in_two_namespaces_is_allowed() -> None:
+    tools = [
+        ResolvedTool(tool=_Tool("list_items"), toolset=_NamedToolset("Bookings")),
+        ResolvedTool(tool=_Tool("list_items"), toolset=_NamedToolset("Inventory")),
+    ]
+    ns = namespacing.build(tools)
+    assert [t.dotted_path for t in ns] == ["bookings.list_items", "inventory.list_items"]
+
+
+def test_bare_tool_may_share_a_name_with_a_namespaced_tool() -> None:
+    tools = [
+        ResolvedTool(tool=_Tool("ping"), toolset=None),
+        ResolvedTool(tool=_Tool("ping"), toolset=_NamedToolset("Slack")),
+    ]
+    ns = namespacing.build(tools)
+    assert [t.dotted_path for t in ns] == ["ping", "slack.ping"]
+    reg = namespacing.Registry(ns)
+    assert reg.resolve_call("ping") is ns[0]
+    assert reg.resolve_call("slack.ping") is ns[1]
+
+
 def test_python_identifier_collisions_raise() -> None:
     tools = [
         ResolvedTool(tool=_Tool("ping"), toolset=None),
@@ -98,3 +129,18 @@ def test_registry_bidirectional_lookup() -> None:
     assert reg.resolve_call("send_message") is ns[0]
     with pytest.raises(KeyError):
         reg.resolve_call("nope")
+
+
+def test_registry_dotted_paths_still_resolve_when_a_name_is_shared() -> None:
+    ns = namespacing.build(
+        [
+            ResolvedTool(tool=_Tool("list_items"), toolset=_NamedToolset("Bookings")),
+            ResolvedTool(tool=_Tool("list_items"), toolset=_NamedToolset("Inventory")),
+        ]
+    )
+    reg = namespacing.Registry(ns)
+    assert reg.resolve_call("bookings.list_items") is ns[0]
+    assert reg.resolve_call("inventory.list_items") is ns[1]
+    assert reg.by_tool_name("list_items") is None
+    with pytest.raises(KeyError):
+        reg.resolve_call("list_items")

{adk_code_mode-1.4.0 → adk_code_mode-1.6.0}/tests/test_stubs_json_schema.py

@@ -224,6 +224,35 @@ class TestApplicatorVocabulary:
             required=["pair"],
         )
         assert "pair: tuple[str, int]" in source
+        # Primitive slots are already in the type; don't repeat them.
+        assert "[0]:" not in source
+        assert "[1]:" not in source
+
+    def test_prefix_items_object_slots_expand_their_properties(self) -> None:
+        source = _render(
+            {
+                "pair": {
+                    "type": "array",
+                    "prefixItems": [
+                        {"type": "string"},
+                        {
+                            "type": "object",
+                            "required": ["lat", "lng"],
+                            "properties": {
+                                "lat": {"type": "number"},
+                                "lng": {"type": "number"},
+                            },
+                        },
+                    ],
+                }
+            },
+            required=["pair"],
+        )
+        assert "pair: tuple[str, dict[str, Any]]" in source
+        assert "[1]: dict[str, Any]" in source
+        assert "lat: float (required)" in source
+        assert "lng: float (required)" in source
+        assert "[0]:" not in source
 
     def test_additional_properties_schema_types_an_open_map(self) -> None:
         source = _render(
@@ -268,6 +297,29 @@ class TestApplicatorVocabulary:
         assert "Min/max capacity range." in source
         assert "min: int" in source
 
+    def test_allof_merges_properties_from_each_branch(self) -> None:
+        """OpenAPI 3.0 extends a `$ref` with extra fields via a second `allOf`
+        object; those keys must join the first object's, not replace them."""
+        source = _render(
+            {
+                "page": {
+                    "allOf": [
+                        {
+                            "type": "object",
+                            "required": ["limit"],
+                            "properties": {"limit": {"type": "integer"}},
+                        },
+                        {
+                            "required": ["cursor"],
+                            "properties": {"cursor": {"type": "string"}},
+                        },
+                    ]
+                }
+            }
+        )
+        assert "limit: int (required)" in source
+        assert "cursor: str (required)" in source
+
     def test_anyof_becomes_a_union_and_a_lone_branch_is_folded(self) -> None:
         source = _render(
             {
@@ -279,6 +331,185 @@ class TestApplicatorVocabulary:
         assert "many: str | int" in source
         assert "one: str" in source
         assert "Only branch." in source
+        # Primitive unions belong in the type expression, not a second listing.
+        assert "-- or --" not in source
+
+    def test_oneof_object_branches_expand_their_properties(self) -> None:
+        """A discriminator union has no `properties` at the `oneOf` itself.
+
+        Folding only the single-branch case leaves `list[dict[str, Any]]` with
+        an empty docstring — the shape of `create_agent(tools=...)`.
+        """
+        source = _render(
+            {
+                "tools": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "type": "object",
+                                "additionalProperties": False,
+                                "required": ["type", "specUrl"],
+                                "properties": {
+                                    "type": {"type": "string", "enum": ["openapi"]},
+                                    "specUrl": {"type": "string"},
+                                    "operationOverrides": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "object",
+                                            "required": ["sourceId", "enabled"],
+                                            "properties": {
+                                                "sourceId": {"type": "string"},
+                                                "enabled": {"type": "boolean"},
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                            {
+                                "type": "object",
+                                "additionalProperties": False,
+                                "required": ["type", "url"],
+                                "properties": {
+                                    "type": {"type": "string", "enum": ["mcp"]},
+                                    "url": {"type": "string"},
+                                    "toolOverrides": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "object",
+                                            "required": ["sourceId", "enabled"],
+                                            "properties": {
+                                                "sourceId": {"type": "string"},
+                                                "enabled": {"type": "boolean"},
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ]
+                    },
+                }
+            },
+            required=["tools"],
+        )
+        assert "tools: list[dict[str, Any]]" in source
+        assert "(type=openapi) (no other keys)" in source
+        assert "specUrl: str (required)" in source
+        assert "operationOverrides: list[dict[str, Any]]" in source
+        assert "-- or --" in source
+        assert "(type=mcp) (no other keys)" in source
+        assert "url: str (required)" in source
+        assert "toolOverrides: list[dict[str, Any]]" in source
+        assert "sourceId: str (required)" in source
+        assert "enabled: bool (required)" in source
+
+    def test_oneof_uses_discriminator_property_for_the_branch_tag(self) -> None:
+        source = _render(
+            {
+                "tool": {
+                    "discriminator": {"propertyName": "kind"},
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "properties": {
+                                "kind": {"const": "http"},
+                                "path": {"type": "string"},
+                            },
+                        },
+                        {
+                            "type": "object",
+                            "properties": {
+                                "kind": {"const": "stdio"},
+                                "command": {"type": "string"},
+                            },
+                        },
+                    ],
+                }
+            }
+        )
+        assert "(kind=http)" in source
+        assert "(kind=stdio)" in source
+        assert "path: str" in source
+        assert "command: str" in source
+
+    def test_parent_required_applies_to_oneof_branch_properties(self) -> None:
+        source = _render(
+            {
+                "target": {
+                    "required": ["value"],
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "properties": {"value": {"type": "string"}},
+                        },
+                        {
+                            "type": "object",
+                            "properties": {"value": {"type": "integer"}},
+                        },
+                    ],
+                }
+            }
+        )
+        assert "value: str (required)" in source
+        assert "value: int (required)" in source
+
+    def test_oneof_branch_prose_is_preserved(self) -> None:
+        source = _render(
+            {
+                "target": {
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "title": "Email target",
+                            "properties": {"value": {"type": "string"}},
+                        },
+                        {
+                            "type": "object",
+                            "description": "Phone target.",
+                            "properties": {"value": {"type": "string"}},
+                        },
+                    ],
+                }
+            }
+        )
+        assert "Email target" in source
+        assert "Phone target." in source
+
+    def test_shared_properties_are_listed_before_oneof_branches(self) -> None:
+        source = _render(
+            {
+                "payment": {
+                    "properties": {"id": {"type": "string"}},
+                    "required": ["id"],
+                    "oneOf": [
+                        {
+                            "type": "object",
+                            "properties": {
+                                "type": {"type": "string", "enum": ["card"]},
+                                "cardNumber": {"type": "string"},
+                            },
+                        },
+                        {
+                            "type": "object",
+                            "properties": {
+                                "type": {"type": "string", "enum": ["bank"]},
+                                "iban": {"type": "string"},
+                            },
+                        },
+                    ],
+                }
+            }
+        )
+        assert "id: str (required)" in source
+        assert "(type=card)" in source
+        assert "cardNumber: str" in source
+        assert "(type=bank)" in source
+        assert "iban: str" in source
+        id_at = source.index("id: str (required)")
+        card_at = source.index("(type=card)")
+        or_at = source.index("-- or --")
+        bank_at = source.index("(type=bank)")
+        assert id_at < card_at < or_at < bank_at
 
 
 class TestMetaDataVocabulary:

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

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