adk-code-mode 1.4.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.4.0 → adk_code_mode-1.5.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adk-code-mode
-Version: 1.4.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"),
@@ -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.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"),
@@ -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.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.4.0"  # x-release-please-version
+__version__ = "1.5.0"  # x-release-please-version

{adk_code_mode-1.4.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.4.0"  # x-release-please-version
+__version__ = "1.5.0"  # x-release-please-version

{adk_code_mode-1.4.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.4.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.4.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")

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

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