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

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

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

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

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.6.1](https://github.com/a2anet/adk-code-mode/compare/adk-code-mode-v1.6.0...adk-code-mode-v1.6.1) (2026-09-22)
+
+
+### Bug Fixes
+
+* exit the sandbox when the host disconnects mid-block ([bd3fb0f](https://github.com/a2anet/adk-code-mode/commit/bd3fb0fb0d8a0cab9370f2ad6db56dfacf566cb4))
+
+## [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)
 
 

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: adk-code-mode
-Version: 1.5.0
+Version: 1.6.1
 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
@@ -300,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`. |
 

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/README.md

@@ -273,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`. |
 

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/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.5.0"  # x-release-please-version
+__version__ = "1.6.1"  # x-release-please-version

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/sandbox-wheel/src/adk_code_mode_sandbox/_entry.py

@@ -228,7 +228,6 @@ def main() -> int:
         port = int(os.environ.get("PORT", "8080"))
         token = os.environ.get(AUTH_TOKEN_ENV)
         asyncio.run(serve(port, token))
-        return 0
 
     reader, writer = _open_control_streams()
     client = RpcClient(reader=reader, writer=writer)

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/sandbox-wheel/src/adk_code_mode_sandbox/_http_server.py

@@ -38,7 +38,7 @@ import shutil
 import tarfile
 import tempfile
 from http import HTTPStatus
-from typing import Any
+from typing import Any, NoReturn
 
 import websockets
 import websockets.asyncio.server
@@ -112,10 +112,11 @@ class _WsBridgeWriter:
         pass
 
 
-async def serve(port: int, token: str | None) -> None:
+async def serve(port: int, token: str | None) -> NoReturn:
     """Start the WebSocket server on *port* with optional bearer *token* auth.
 
-    Accepts exactly one WebSocket connection, runs user code, then returns.
+    Accepts exactly one WebSocket connection, runs user code, then exits the
+    process.
     """
     stop = asyncio.Event()
     accepted = False
@@ -136,9 +137,15 @@ async def serve(port: int, token: str | None) -> None:
         return None
 
     async def handler(ws: Any) -> None:
+        turn = asyncio.create_task(_handle_connection(ws))
+        # End the turn when the socket closes, even mid-block: user code that
+        # ignores the disconnect would otherwise keep this single-use container
+        # alive, answering every later connection with "Busy".
+        ws_closed = asyncio.create_task(ws.wait_closed())
+        ws_closed.add_done_callback(lambda _: turn.cancel())
         try:
-            await _handle_connection(ws)
-        except websockets.ConnectionClosed:
+            await turn
+        except (websockets.ConnectionClosed, asyncio.CancelledError):
             logger.debug("client disconnected")
         except Exception:
             logger.exception("error handling WebSocket connection")
@@ -154,6 +161,9 @@ async def serve(port: int, token: str | None) -> None:
     ):
         logger.info("sandbox HTTP server listening on port %d", port)
         await stop.wait()
+    # Don't let interpreter shutdown join a worker thread still running user code
+    # the host has given up on.
+    os._exit(0)
 
 
 async def _handle_connection(ws: Any) -> None:

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/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.5.0"  # x-release-please-version
+__version__ = "1.6.1"  # x-release-please-version

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/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.5.0 → adk_code_mode-1.6.1}/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.5.0 → adk_code_mode-1.6.1}/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.5.0 → adk_code_mode-1.6.1}/tests/test_remote_integration.py

@@ -340,3 +340,38 @@ async def test_remote_close_shuts_the_container_down(
             break
         await asyncio.sleep(0.02)
     assert http_server.poll() is not None  # container exited after ShutdownFrame
+
+
+@pytest.mark.asyncio
+async def test_remote_timed_out_block_shuts_the_container_down(
+    http_server: subprocess.Popen[bytes],
+) -> None:
+    """A block still running when the host gives up doesn't keep the server alive."""
+    artifact_service = InMemoryArtifactService()
+    session = Session(
+        id="remote-timeout",
+        app_name="test-app",
+        user_id="u1",
+        state={},
+        events=[],
+        last_update_time=0.0,
+    )
+    ctx = _make_ctx(artifact_service, session)
+
+    tool = ExecuteCodeTool(
+        tools=[],
+        backend=RemoteBackend(url=_server_url(http_server)),
+        max_output_chars=10_000,
+        timeout_seconds=1,
+    )
+    result = await tool.run_async(
+        args={"code": "import time\ntime.sleep(3600)\n"},
+        tool_context=_tool_context(ctx, call_id="remote-timeout-1"),
+    )
+    assert "exceeded timeout" in result["stderr"]
+
+    for _ in range(200):
+        if http_server.poll() is not None:
+            break
+        await asyncio.sleep(0.02)
+    assert http_server.poll() is not None  # container exited despite the running block

{adk_code_mode-1.5.0 → adk_code_mode-1.6.1}/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.5.0/.release-please-manifest.json

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