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

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

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

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

@@ -1,5 +1,24 @@
 # Changelog
 
+## [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)
+
+
+### 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.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adk-code-mode
-Version: 1.3.0
+Version: 1.5.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"),

{adk_code_mode-1.3.0 → adk_code_mode-1.5.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"),

{adk_code_mode-1.3.0 → adk_code_mode-1.5.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.5.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.5.0"  # x-release-please-version

{adk_code_mode-1.3.0 → adk_code_mode-1.5.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.5.0"  # x-release-please-version

{adk_code_mode-1.3.0 → adk_code_mode-1.5.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.3.0 → adk_code_mode-1.5.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.5.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.3.0 → adk_code_mode-1.5.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")