From 9fcdf918e0c4e61df1e075efd02ae402a42bf6de Mon Sep 17 00:00:00 2001 From: evanlowe <62918515+evanlowe@users.noreply.github.com> Date: Sat, 14 Nov 2026 11:45:09 +0800 Subject: [PATCH] fix(deps): support Google ADK 2.11 --- pyproject.toml | 6 +- tests/cli/test_studio_startup_imports.py | 96 +++++++ tests/test_adk_dynamic_agent_transfer.py | 260 ++++++++++++++++++ tests/test_adk_sync_tool_thread_pool_patch.py | 152 ++++++++++ .../test_runtime_dependency_compatibility.py | 8 +- uv.lock | 91 +++--- veadk/cli/studio_start.py | 162 +++++++---- veadk/utils/patches.py | 73 ++++- 8 files changed, 739 insertions(+), 109 deletions(-) create mode 100644 tests/test_adk_dynamic_agent_transfer.py diff --git a/pyproject.toml b/pyproject.toml index 6779d7f22..b22d19771 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,11 +20,11 @@ dependencies = [ "pydantic-settings==2.10.1", # Config management "a2a-sdk>=0.3.7,<1.0.0", # For Google Agent2Agent protocol "deprecated==1.2.18", - "google-adk>=2.7.0,<2.8.0", # For basic agent architecture + "google-adk>=2.7.0,<2.12.0", # For basic agent architecture # litellm and sqlalchemy are required by code paths veadk always uses # (LiteLlm models, sessions). google-adk ships them in base on 1.x but moved # them behind extras ([extensions]/[db]) on 2.x, so declare them directly to - # stay compatible across google-adk >= 2.7.0,<2.8.0. + # keep these imports available without requiring ADK extras. "litellm>=1.83.7,<=1.83.14", # google-adk LiteLlm model ([extensions] on 2.x) # The `asyncio` extra is what pulls greenlet, which SQLAlchemy's async # engine requires and which ADK's DatabaseSessionService therefore needs. @@ -124,7 +124,7 @@ pdf = [] # Backward-compatible alias; PDF support is now installed by default eval = [ "prometheus-client>=0.22.1", # For exporting data to Prometheus pushgateway "deepeval>=3.2.6", # For DeepEval-based evaluation - "google-adk[eval]>=2.7.0,<2.8.0", # For Google ADK-based evaluation + "google-adk[eval]>=2.7.0,<2.12.0", # For Google ADK-based evaluation ] harness = [ "headroom", diff --git a/tests/cli/test_studio_startup_imports.py b/tests/cli/test_studio_startup_imports.py index 1bd44841c..b5af46ef9 100644 --- a/tests/cli/test_studio_startup_imports.py +++ b/tests/cli/test_studio_startup_imports.py @@ -1110,6 +1110,102 @@ def test_studio_deferred_genai_models_support_openapi_first_use() -> None: ) +def test_studio_deferred_genai_fields_preserve_aliases_and_argument_hints() -> None: + root = Path(__file__).resolve().parents[2] + script = """ +import sys +import tempfile + +from veadk.cli.studio_start import studio_fast_api_factory + +with tempfile.TemporaryDirectory() as agents_dir: + studio_fast_api_factory()(agents_dir=agents_dir, web=False) + +from google.genai import types + +loaded = types._veadk_real_module_loaded +fields = types.GenerateContentConfig.model_fields +aliases = {name: field.alias for name, field in fields.items()} +assert aliases["top_p"] == "topP" +assert not loaded() + +from google.adk.agents import llm_agent +from pydantic import ValidationError + +if hasattr(llm_agent, "_GENERATE_CONTENT_FIELD_NAMES"): + try: + llm_agent.LlmAgent(name="test", model="unused", topP=0.5) + except ValidationError as error: + assert "GenerateContentConfig" in str(error) + assert "top_p" in str(error) + else: + raise AssertionError("misplaced generation field was accepted") +assert not loaded() + +annotation = fields["temperature"].annotation +assert loaded() +real_fields = sys.modules["google.genai.types"].GenerateContentConfig.model_fields +assert aliases == {name: field.alias for name, field in real_fields.items()} +assert annotation == real_fields["temperature"].annotation +assert types.GenerateContentConfig.model_fields is real_fields +""" + result = subprocess.run( + [sys.executable, "-c", script], + cwd=root, + capture_output=True, + text=True, + timeout=60, + ) + assert result.returncode == 0, result.stderr + + +def test_studio_deferred_genai_client_preserves_injection_and_validation() -> None: + root = Path(__file__).resolve().parents[2] + script = """ +import sys +import tempfile + +from veadk.cli.studio_start import studio_fast_api_factory + +with tempfile.TemporaryDirectory() as agents_dir: + studio_fast_api_factory()(agents_dir=agents_dir, web=False) + +from google import genai +from google.adk.models.google_llm import Gemini +from pydantic import ConfigDict, TypeAdapter, ValidationError + +deferred_client = genai.Client +adapter = TypeAdapter(deferred_client, config=ConfigDict(arbitrary_types_allowed=True)) +assert "google.genai.client" not in sys.modules +client = deferred_client(api_key="test-only-key") +try: + assert type(client) is sys.modules["google.genai.client"].Client + assert isinstance(client, deferred_client) + assert adapter.validate_python(client) is client + if "client" in Gemini.model_fields: + assert Gemini(client=client).client is client + validate = lambda value: Gemini(client=value) + else: + validate = adapter.validate_python + try: + validate(object()) + except ValidationError: + pass + else: + raise AssertionError("invalid Client instance was accepted") +finally: + client.close() +""" + result = subprocess.run( + [sys.executable, "-c", script], + cwd=root, + capture_output=True, + text=True, + timeout=60, + ) + assert result.returncode == 0, result.stderr + + def test_studio_deferred_genai_types_accept_evaluation_output_schema() -> None: root = Path(__file__).resolve().parents[2] script = """ diff --git a/tests/test_adk_dynamic_agent_transfer.py b/tests/test_adk_dynamic_agent_transfer.py new file mode 100644 index 000000000..61327c7c6 --- /dev/null +++ b/tests/test_adk_dynamic_agent_transfer.py @@ -0,0 +1,260 @@ +# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Exercise transfer routing through the real Runner without a cloud model.""" + +from __future__ import annotations + +import asyncio +from collections.abc import AsyncGenerator +from types import SimpleNamespace + +import pytest +from google.adk.agents import BaseAgent +from google.adk.events import Event +from google.adk.models.base_llm import BaseLlm +from google.adk.models.llm_response import LlmResponse +from google.adk.runners import InMemoryRunner +from google.adk.workflow import _dynamic_node_scheduler +from google.genai import types +from packaging.version import Version + +from veadk import Agent +from veadk.tools.builtin_tools.create_agent import CreateAgentToolset +from veadk.utils.adk_compat import get_adk_version +from veadk.utils.patches import patch_adk_dynamic_agent_transfer + +if get_adk_version() >= Version("2.8.0"): + from google.adk.workflow.utils import _transfer_utils +else: + _transfer_utils = None + + +class _RoutingModel(BaseLlm): + targets: list[str] + calls: int = 0 + + async def generate_content_async( + self, llm_request, stream: bool = False + ) -> AsyncGenerator[LlmResponse, None]: + del llm_request, stream + index = self.calls + self.calls += 1 + if index < len(self.targets): + part = types.Part( + function_call=types.FunctionCall( + id=f"transfer-{self.model}-{index}", + name="transfer_to_agent", + args={"agent_name": self.targets[index]}, + ) + ) + else: + part = types.Part(text=f"done:{self.model}") + yield LlmResponse(content=types.ModelContent(parts=[part])) + + +def _agent(name: str, targets: list[str], children: list[BaseAgent] | None = None): + return Agent( + name=name, + model=_RoutingModel(model=name, targets=targets), + model_api_key="test-key", + sub_agents=children or [], + ) + + +async def _run(runner: InMemoryRunner, session_id: str) -> list[Event]: + await runner.session_service.create_session( + app_name=runner.app_name, user_id="test-user", session_id=session_id + ) + return [ + event + async for event in runner.run_async( + user_id="test-user", + session_id=session_id, + new_message=types.UserContent(parts=[types.Part(text=session_id)]), + ) + ] + + +@pytest.mark.asyncio +@pytest.mark.parametrize("route", ["child", "parent", "sibling"]) +async def test_runner_preserves_static_agent_transfer_routes(route: str) -> None: + first_targets = {"child": [], "parent": ["main"], "sibling": ["second"]}[route] + first = _agent("first", first_targets) + children = [first] + if route == "sibling": + children.append(_agent("second", [])) + main = _agent("main", ["first"], children) + runner = InMemoryRunner(agent=main, app_name="static-transfers") + + events = await _run(runner, f"static-{route}") + + expected_target = {"child": "first", "parent": "main", "sibling": "second"}[route] + assert any( + event.author == expected_target + and event.content + and any( + part.text == f"done:{expected_target}" + for part in (event.content.parts or []) + ) + for event in events + ) + assert [child.name for child in main.sub_agents] == [ + child.name for child in children + ] + assert all(child.parent_agent is main for child in children) + + +class _DynamicModel(BaseLlm): + async def generate_content_async( + self, llm_request, stream: bool = False + ) -> AsyncGenerator[LlmResponse, None]: + del stream + await asyncio.sleep(0) + collection = next( + ( + part.function_response.response["collection_id"] + for content in reversed(llm_request.contents or []) + for part in (content.parts or []) + if part.function_response + and part.function_response.name == "collect_resources" + ), + None, + ) + if collection is None: + call = types.FunctionCall(id="collect", name="collect_resources", args={}) + else: + call = types.FunctionCall( + id="create", + name="create_agents", + args={ + "collection_id": collection, + "handoff_to": "specialist", + "agents": [ + { + "name": "specialist", + "task": "work", + "root_node": "worker", + "nodes": [ + {"id": "worker", "type": "llm", "instruction": "work"} + ], + } + ], + }, + ) + yield LlmResponse( + content=types.ModelContent(parts=[types.Part(function_call=call)]) + ) + + +class _TextAgent(BaseAgent): + async def _run_async_impl(self, ctx): + del ctx + yield Event( + author=self.name, + content=types.ModelContent(parts=[types.Part(text=self.name)]), + ) + + +def _leaf_factory(node, tools, workflow_member, parent_agent): + del tools, workflow_member, parent_agent + return _TextAgent(name=node.id) + + +def test_transfer_patch_is_idempotent_or_noop_on_older_adk() -> None: + before = getattr(_transfer_utils, "resolve_and_derive_transfer_context", None) + patch_adk_dynamic_agent_transfer() + patch_adk_dynamic_agent_transfer() + assert ( + getattr(_transfer_utils, "resolve_and_derive_transfer_context", None) is before + ) + if hasattr(_dynamic_node_scheduler, "resolve_and_derive_transfer_context"): + assert _dynamic_node_scheduler.resolve_and_derive_transfer_context is before + + +@pytest.mark.skipif( + get_adk_version() < Version("2.9.0"), + reason="Native parent and peer transfer restrictions were added in ADK 2.9", +) +@pytest.mark.parametrize("target", ["main", "second"]) +def test_executing_clone_keeps_parent_and_peer_transfer_restrictions( + target: str, +) -> None: + main = _agent("main", [], [_agent("first", []), _agent("second", [])]) + template = main.sub_agents[0] + runtime_root = main.clone() + active = runtime_root.sub_agents[0] + active.disallow_transfer_to_parent = True + active.disallow_transfer_to_peers = True + + with pytest.raises(ValueError, match="disallow_transfer_to_"): + _transfer_utils.resolve_and_derive_transfer_context( + target_name=target, + current_agent=template, + root_agent=main, + curr_ctx=SimpleNamespace(node=active), + curr_parent_ctx=None, + ) + + +@pytest.mark.asyncio +@pytest.mark.skipif( + _transfer_utils is None, + reason="ADK 2.7 does not clone chat agents through the workflow scheduler", +) +async def test_concurrent_dynamic_transfers_keep_agents_off_shared_root() -> None: + toolset = CreateAgentToolset(resource_sources=[], leaf_factory=_leaf_factory) + main = Agent( + name="main", + model=_DynamicModel(model="dynamic"), + model_api_key="test-key", + tools=[toolset], + ) + initial_children = tuple(main.sub_agents) + runner = InMemoryRunner(agent=main, app_name="isolated-dynamic-transfers") + try: + runs = await asyncio.gather( + _run(runner, "session-one"), _run(runner, "session-two") + ) + targets = [] + parents = [] + for events in runs: + target = next( + event.actions.transfer_to_agent + for event in events + if event.actions.transfer_to_agent + ) + targets.append(target) + assert any( + event.author == target + and event.content + and any(part.text == target for part in (event.content.parts or [])) + for event in events + ) + parent, _, _ = toolset._registrations[target] + parents.append(parent) + assert parent is not main + assert [ + child.name + for child in parent.sub_agents + if child.name.startswith("specialist__") + ] == [target] + assert targets[0] != targets[1] + assert parents[0] is not parents[1] + assert tuple(main.sub_agents) == initial_children + for events, other_target in zip(runs, reversed(targets), strict=True): + assert all(event.author != other_target for event in events) + finally: + await toolset.close() + assert toolset._registrations == {} diff --git a/tests/test_adk_sync_tool_thread_pool_patch.py b/tests/test_adk_sync_tool_thread_pool_patch.py index bc5ca2dd2..b0e38b354 100644 --- a/tests/test_adk_sync_tool_thread_pool_patch.py +++ b/tests/test_adk_sync_tool_thread_pool_patch.py @@ -14,6 +14,7 @@ from __future__ import annotations +import asyncio import time import pytest @@ -21,13 +22,18 @@ from google.adk.agents.invocation_context import InvocationContext from google.adk.agents.run_config import ToolThreadPoolConfig from google.adk.flows.llm_flows import functions +from google.adk.models.base_llm import BaseLlm +from google.adk.models.llm_response import LlmResponse +from google.adk.runners import InMemoryRunner from google.adk.sessions.in_memory_session_service import InMemorySessionService from google.adk.sessions.session import Session +from google.adk.tools.agent_tool import AgentTool from google.adk.tools.function_tool import FunctionTool from google.adk.tools.tool_context import ToolContext from google.genai import types from veadk import Agent +from veadk.tools.builtin_tools import run_code as run_code_module from veadk.utils.patches import patch_adk_sync_tool_thread_pool @@ -202,3 +208,149 @@ async def test_run_code_uses_agent_thread_pool_when_configured() -> None: assert start_gap < 0.1 assert parallel_call_counts == {"a": 2, "b": 2} assert _overlapped(windows) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("configure_runner", [False, True]) +async def test_async_tools_keep_the_callers_event_loop(configure_runner) -> None: + caller_loop = asyncio.get_running_loop() + + async def async_tool() -> dict: + await asyncio.sleep(0) + return {"same_loop": asyncio.get_running_loop() is caller_loop} + + pool = ToolThreadPoolConfig(max_workers=2) + tool = FunctionTool(async_tool) + agent = Agent( + name="agent", + model_name="test-model", + model_provider="openai", + model_api_key="test-key", + model_api_base="http://example.com", + tools=[tool], + tool_thread_pool_config=None if configure_runner else pool, + ) + response = await functions.handle_function_call_list_async( + _ctx( + agent, RunConfig(tool_thread_pool_config=pool if configure_runner else None) + ), + [types.FunctionCall(id="async-call", name="async_tool", args={})], + {tool.name: tool}, + ) + + assert response.get_function_responses()[0].response == {"same_loop": True} + + +class _ToolCallingModel(BaseLlm): + tool_name: str = "run_code" + + async def generate_content_async(self, llm_request, stream=False): + del stream + has_response = any( + part.function_response + for content in llm_request.contents + for part in content.parts or [] + ) + if has_response: + parts = [types.Part(text="done")] + elif self.tool_name == "run_code": + parts = [ + types.Part( + function_call=types.FunctionCall( + id=f"call-{label}", + name="run_code", + args={"code": label, "language": "python3"}, + ) + ) + for label in ("a", "b") + ] + else: + parts = [ + types.Part( + function_call=types.FunctionCall( + name=self.tool_name, args={"request": "run both tools"} + ) + ) + ] + yield LlmResponse(content=types.Content(role="model", parts=parts)) + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + ("agent_workers", "run_workers", "nested", "overlap"), + [ + (2, None, False, True), + (2, 1, False, False), + (None, 2, False, True), + (2, None, True, True), + ], +) +async def test_runner_preserves_thread_pool_config_and_run_code_isolation( + monkeypatch, agent_workers, run_workers, nested, overlap +) -> None: + windows: dict[str, tuple[float, float]] = {} + session_ids: dict[str, str] = {} + + def invoke(**kwargs): + label = kwargs["code"] + started = time.perf_counter() + session_ids[label] = kwargs["tool_user_session_id"] + time.sleep(0.1) + windows[label] = (started, time.perf_counter()) + return {"Result": {"Result": label}} + + monkeypatch.delenv("VEADK_RUN_CODE_ISOLATE_PARALLEL_CALLS", raising=False) + monkeypatch.setattr(run_code_module, "resolve_agentkit_tool_id", lambda _: "tool") + monkeypatch.setattr( + run_code_module, + "get_agentkit_endpoint_config", + lambda: ("service", "region", "host", "https"), + ) + monkeypatch.setattr(run_code_module, "invoke_agentkit_run_code", invoke) + agent = Agent( + name="worker", + model=_ToolCallingModel(model="fake"), + model_api_key="test-key", + tools=[run_code_module.run_code], + tool_thread_pool_config=( + ToolThreadPoolConfig(max_workers=agent_workers) + if agent_workers is not None + else None + ), + ) + if nested: + agent = Agent( + name="parent", + model=_ToolCallingModel(model="fake", tool_name="worker"), + model_api_key="test-key", + tools=[AgentTool(agent=agent)], + tool_thread_pool_config=ToolThreadPoolConfig(max_workers=1), + ) + runner = InMemoryRunner(agent=agent, app_name="test-app") + await runner.session_service.create_session( + app_name="test-app", user_id="user", session_id="session" + ) + run_config = RunConfig( + tool_thread_pool_config=( + ToolThreadPoolConfig(max_workers=run_workers) + if run_workers is not None + else None + ) + ) + original_config = run_config.model_dump() + events = [ + event + async for event in runner.run_async( + user_id="user", + session_id="session", + new_message=types.UserContent(parts=[types.Part(text="run")]), + run_config=run_config, + ) + ] + + assert _overlapped(windows) is overlap + assert session_ids["a"].endswith("_call-a") + assert session_ids["b"].endswith("_call-b") + assert session_ids["a"] != session_ids["b"] + assert run_config.model_dump() == original_config + assert events[-1].is_final_response() diff --git a/tests/test_runtime_dependency_compatibility.py b/tests/test_runtime_dependency_compatibility.py index 2a5135bb8..e082a0054 100644 --- a/tests/test_runtime_dependency_compatibility.py +++ b/tests/test_runtime_dependency_compatibility.py @@ -22,8 +22,8 @@ ROOT = Path(__file__).resolve().parents[1] -GOOGLE_ADK_BASELINE = "google-adk>=2.7.0,<2.8.0" -GOOGLE_ADK_EVAL_BASELINE = "google-adk[eval]>=2.7.0,<2.8.0" +GOOGLE_ADK_BASELINE = "google-adk>=2.7.0,<2.12.0" +GOOGLE_ADK_EVAL_BASELINE = "google-adk[eval]>=2.7.0,<2.12.0" AGENTKIT_BASELINE = "agentkit-sdk-python>=0.8.5" OPENTELEMETRY_EXPORTER_BASELINE = "opentelemetry-exporter-otlp>=1.37.0,<1.43" OPENTELEMETRY_EXPORTER_LOCK_BASELINE = ( @@ -55,9 +55,9 @@ def test_lock_metadata_matches_project_dependency_baseline() -> None: '{ name = "agentkit-sdk-python", marker = "extra == ' '\'harness-sidecar\'", specifier = ">=0.8.5" }' ) in lock - assert '{ name = "google-adk", specifier = ">=2.7.0,<2.8.0" }' in lock + assert '{ name = "google-adk", specifier = ">=2.7.0,<2.12.0" }' in lock assert ( '{ name = "google-adk", extras = ["eval"], marker = "extra == ' - '\'eval\'", specifier = ">=2.7.0,<2.8.0" }' + '\'eval\'", specifier = ">=2.7.0,<2.12.0" }' ) in lock assert OPENTELEMETRY_EXPORTER_LOCK_BASELINE in lock diff --git a/uv.lock b/uv.lock index d4610f8eb..807cb0be4 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.10, <3.14" resolution-markers = [ "python_full_version >= '3.13' and sys_platform == 'win32'", @@ -117,7 +117,7 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "caio", version = "0.9.25", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "caio", version = "0.9.25", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" } wheels = [ @@ -140,7 +140,7 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "caio", version = "0.12.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "caio", version = "0.12.2", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/14/31/edb06aabd8f8f0b56d659f30800795f40b93cba96be946ce179f6931e3a5/aiofile-3.12.3.tar.gz", hash = "sha256:caa6aa746b5e47e2165f7abd741b6415e49cf4d44fddc0f61844612cc3924d41", size = 21600, upload-time = "2026-08-04T22:59:27.171Z" } wheels = [ @@ -1244,9 +1244,9 @@ name = "faiss-cpu" version = "1.15.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.12' and sys_platform != 'win32') or (python_full_version < '3.11' and sys_platform == 'win32')" }, - { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' and sys_platform != 'win32'" }, - { name = "packaging", marker = "python_full_version < '3.11' or sys_platform != 'win32'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/59/68/20e91694ad9a8b2bb48af956899e52b645cb1501e7e2ec31cb733da4d4c5/faiss_cpu-1.15.0-cp310-abi3-macosx_14_0_arm64.whl", hash = "sha256:50ea471ef1f4f3580eda8ab0ec9727d4bf65fd71c444bf306ce7cdbba8a42b21", size = 4904897, upload-time = "2026-08-03T17:49:37.003Z" }, @@ -1527,10 +1527,9 @@ wheels = [ [[package]] name = "google-adk" -version = "2.7.1" +version = "2.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp" }, { name = "aiosqlite" }, { name = "authlib" }, { name = "click" }, @@ -1551,14 +1550,13 @@ dependencies = [ { name = "starlette" }, { name = "tenacity" }, { name = "typing-extensions" }, - { name = "tzlocal" }, { name = "uvicorn" }, { name = "watchdog" }, { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/02/55/63336b5cd9679a32b36cb14971a7461811db20126bb63cb092fe653b8d54/google_adk-2.7.1.tar.gz", hash = "sha256:0485bfba1a04960a3784eb67531491475be1a3f8acefcc5c880a906857ecb3e2", size = 3806947, upload-time = "2026-08-17T18:33:11.841Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/50/7e9d83adc67df40752598bddcc24d9b6696aae4d61c45b6271d53ec2df53/google_adk-2.11.0.tar.gz", hash = "sha256:59258cec8d79306192bf65e0d43fa64b764f831e3b74ed3b8e6fe9df16a1e2c8", size = 4197119, upload-time = "2026-10-02T00:46:25.232Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/ed/6b3da8b43525d9b28a95836abb1042abc26fe1e8be9f63eb01c18b70d4d4/google_adk-2.7.1-py3-none-any.whl", hash = "sha256:cd21e37c9846a80086fd880924aa5548e625ef85178122b40cda81ef5316129f", size = 4396591, upload-time = "2026-08-17T18:33:09.596Z" }, + { url = "https://files.pythonhosted.org/packages/b3/44/b4f54c46f1c6a32318891ff2be25d854f4c5b5b9ed8ac507ed9466f1ccc8/google_adk-2.11.0-py3-none-any.whl", hash = "sha256:4774e1fc7bb37727e56142e7d41e9035949ebfc876a2b15d5505969b02798bcd", size = 4871441, upload-time = "2026-10-02T00:46:23.264Z" }, ] [package.optional-dependencies] @@ -1568,10 +1566,12 @@ eval = [ { name = "google-cloud-texttospeech" }, { name = "jinja2" }, { name = "nltk" }, + { name = "openpyxl" }, { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, { name = "pandas", version = "3.0.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "rouge-score" }, { name = "tabulate" }, + { name = "xlrd" }, ] [[package]] @@ -2083,8 +2083,8 @@ name = "httpcore2" version = "2.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "h11", marker = "python_full_version < '3.11' or sys_platform != 'emscripten'" }, - { name = "truststore", marker = "python_full_version < '3.11' or sys_platform != 'emscripten'" }, + { name = "h11" }, + { name = "truststore" }, ] sdist = { url = "https://files.pythonhosted.org/packages/be/ad/f4f0e57345f1870f3e8cb624e058d7eca6e5a27d33bcc3311d9b618734cd/httpcore2-2.12.0.tar.gz", hash = "sha256:9293522bba0aa7c4c8e9e3f040c16575bd8868e155a77fa30c7a9085a5eae648", size = 67548, upload-time = "2026-08-18T13:22:08.211Z" } wheels = [ @@ -2962,11 +2962,11 @@ name = "milvus-lite" version = "3.2.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "faiss-cpu", marker = "python_full_version < '3.11' or sys_platform != 'win32'" }, - { name = "grpcio", marker = "python_full_version < '3.11' or sys_platform != 'win32'" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.12' and sys_platform != 'win32') or (python_full_version < '3.11' and sys_platform == 'win32')" }, - { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12' and sys_platform != 'win32'" }, - { name = "pyarrow", marker = "python_full_version < '3.11' or sys_platform != 'win32'" }, + { name = "faiss-cpu" }, + { name = "grpcio" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "pyarrow" }, { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/16/48/3826b9b18621aa38548ed59749a3a2df0578a1262f8aeeed5cdeb7a9fb94/milvus_lite-3.2.1.tar.gz", hash = "sha256:4d988fe0a6bbdfc708046014ad69f4b140c43567ecafd8b6df300ad7d37210f3", size = 722376, upload-time = "2026-08-25T03:14:40.772Z" } @@ -3608,10 +3608,10 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "python-dateutil", marker = "python_full_version < '3.11'" }, - { name = "pytz", marker = "python_full_version < '3.11'" }, - { name = "tzdata", marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, ] sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } wheels = [ @@ -3667,10 +3667,10 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, - { name = "python-dateutil", marker = "python_full_version >= '3.11'" }, - { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/be/4f/5f3422a2afec5ffc46308b79e53291365a93748b498ac2e58bead0197916/pandas-3.0.5.tar.gz", hash = "sha256:dca3734d6ab7c906e6730f0788b0a1dbb9f2467731f9711f77995c8e9d62d712", size = 4658219, upload-time = "2026-07-22T22:19:28.819Z" } wheels = [ @@ -5089,10 +5089,10 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "joblib", marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "threadpoolctl", marker = "python_full_version < '3.11'" }, + { name = "joblib" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, + { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" } }, + { name = "threadpoolctl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/37/59/44985a2bdc95c74e34fef3d10cb5d93ce13b0e2a7baefffe1b53853b502d/scikit_learn-1.5.2.tar.gz", hash = "sha256:b4237ed7b3fdd0a4882792e68ef2545d5baa50aca3bb45aa7df468138ad8f94d", size = 7001680, upload-time = "2024-09-11T15:50:10.957Z" } wheels = [ @@ -5134,13 +5134,13 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "joblib", marker = "python_full_version >= '3.11'" }, - { name = "narwhals", marker = "python_full_version >= '3.11'" }, - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "joblib" }, + { name = "narwhals" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, - { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, { name = "scipy", version = "1.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, - { name = "threadpoolctl", marker = "python_full_version >= '3.11'" }, + { name = "threadpoolctl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fa/6f/37092bdb25f712817231799fc5674d8e704066a8a70c1d2d40517e18b4ab/scikit_learn-1.9.0.tar.gz", hash = "sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557", size = 7750767, upload-time = "2026-06-02T11:54:32.706Z" } wheels = [ @@ -5172,7 +5172,7 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" } wheels = [ @@ -5233,7 +5233,7 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "1.26.4", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } wheels = [ @@ -5292,7 +5292,7 @@ resolution-markers = [ "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/7e/74/66de6258867beb2ef08f35f9f2ac017a52cacd5081714d239ff1a442d458/scipy-1.18.1.tar.gz", hash = "sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307", size = 30781235, upload-time = "2026-08-21T23:28:50.599Z" } wheels = [ @@ -5323,8 +5323,8 @@ name = "secretstorage" version = "3.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" }, - { name = "jeepney", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" }, + { name = "cryptography" }, + { name = "jeepney" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } wheels = [ @@ -5957,8 +5957,8 @@ requires-dist = [ { name = "fastapi", marker = "extra == 'codex'" }, { name = "fastmcp", specifier = ">=2.12.3,<4" }, { name = "filetype", specifier = "==1.2.0" }, - { name = "google-adk", specifier = ">=2.7.0,<2.8.0" }, - { name = "google-adk", extras = ["eval"], marker = "extra == 'eval'", specifier = ">=2.7.0,<2.8.0" }, + { name = "google-adk", specifier = ">=2.7.0,<2.12.0" }, + { name = "google-adk", extras = ["eval"], marker = "extra == 'eval'", specifier = ">=2.7.0,<2.12.0" }, { name = "headroom", marker = "extra == 'harness'" }, { name = "httpx", specifier = ">=0.27,<1" }, { name = "httpx", extras = ["socks"], marker = "extra == 'sandbox'", specifier = ">=0.27.0" }, @@ -6376,6 +6376,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594, upload-time = "2025-01-14T10:35:44.018Z" }, ] +[[package]] +name = "xlrd" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/07/5a/377161c2d3538d1990d7af382c79f3b2372e880b65de21b01b1a2b78691e/xlrd-2.0.2.tar.gz", hash = "sha256:08b5e25de58f21ce71dc7db3b3b8106c1fa776f3024c54e45b45b374e89234c9", size = 100167, upload-time = "2025-06-14T08:46:39.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/62/c8d562e7766786ba6587d09c5a8ba9f718ed3fa8af7f4553e8f91c36f302/xlrd-2.0.2-py2.py3-none-any.whl", hash = "sha256:ea762c3d29f4cca48d82df517b6d89fbce4db3107f9d78713e48cd321d5c9aa9", size = 96555, upload-time = "2025-06-14T08:46:37.766Z" }, +] + [[package]] name = "yarl" version = "1.24.5" diff --git a/veadk/cli/studio_start.py b/veadk/cli/studio_start.py index 4f188c658..88c0f3c0e 100644 --- a/veadk/cli/studio_start.py +++ b/veadk/cli/studio_start.py @@ -17,6 +17,7 @@ from __future__ import annotations import ast +from collections.abc import Callable from enum import Enum import importlib import importlib.machinery @@ -127,8 +128,63 @@ def __getattr__(cls, attribute: str) -> Any: ) load_real = cls.__dict__["_load_real_module"] target_name = cls.__dict__["_target_name"] + if attribute == "model_fields" and "_deferred_model_fields" in cls.__dict__: + return cls.__dict__["_deferred_model_fields"]() return getattr(getattr(load_real(), target_name), attribute) + def __instancecheck__(cls, instance: Any) -> bool: + load_real = cls.__dict__["_load_real_module"] + return isinstance(instance, getattr(load_real(), cls.__dict__["_target_name"])) + + +def _deferred_genai_type( + target_name: str, + module_name: str, + load_real_module: Callable[[], ModuleType], +) -> type[Any]: + def _validate(value: Any) -> Any: + target = getattr(load_real_module(), target_name) + try: + if isinstance(value, target): + return value + except TypeError: + pass + model_validate = getattr(target, "model_validate", None) + if callable(model_validate): + return model_validate(value) + from pydantic import ConfigDict, TypeAdapter + + # GenAI aliases can include arbitrary types, as can an injected Client. + return TypeAdapter( + target, config=ConfigDict(arbitrary_types_allowed=True) + ).validate_python(value) + + def _core_schema(cls: type[Any], source_type: Any, handler: Any) -> Any: + del cls, source_type, handler + from pydantic_core import core_schema + + return core_schema.no_info_after_validator_function( + _validate, core_schema.any_schema() + ) + + def _json_schema(cls: type[Any], schema: Any, handler: Any) -> dict[str, Any]: + del cls, schema, handler + from pydantic import TypeAdapter + + return TypeAdapter(getattr(load_real_module(), target_name)).json_schema() + + return _DeferredGenaiTypeMeta( + target_name, + (), + { + "__module__": module_name, + "_target_name": target_name, + "_load_real_module": staticmethod(load_real_module), + "__get_pydantic_core_schema__": classmethod(_core_schema), + "__get_pydantic_json_schema__": classmethod(_json_schema), + }, + ) + def _install_lazy_genai_types() -> ModuleType: """Defer generated Google GenAI models until an ADK request uses them.""" @@ -185,64 +241,58 @@ class _DeferredGenaiType(str, Enum): _DeferredGenaiType.__module__ = name setattr(proxy, "Type", _DeferredGenaiType) - def _deferred_type(target_name: str) -> type[Any]: - def _validate(value: Any) -> Any: - target = getattr(_load_real_module(), target_name) - try: - if isinstance(value, target): - return value - except TypeError: - pass - model_validate = getattr(target, "model_validate", None) - if callable(model_validate): - return model_validate(value) - from pydantic import ConfigDict, TypeAdapter - - # GenAI aliases such as SchemaUnion include GenericAlias and - # UnionType, matching its own arbitrary-types model configuration. - return TypeAdapter( - target, config=ConfigDict(arbitrary_types_allowed=True) - ).validate_python(value) - - def _core_schema( - cls: type[Any], - source_type: Any, - handler: Any, - ) -> Any: - del cls, source_type, handler - from pydantic_core import core_schema - - return core_schema.no_info_after_validator_function( - _validate, - core_schema.any_schema(), - ) + class _DeferredField: + def __init__(self, field_name: str, alias: str) -> None: + self.name = field_name + self.alias = alias - def _json_schema( - cls: type[Any], - schema: Any, - handler: Any, - ) -> dict[str, Any]: - del cls, schema, handler - from pydantic import TypeAdapter - - return TypeAdapter(getattr(_load_real_module(), target_name)).json_schema() - - return _DeferredGenaiTypeMeta( - target_name, - (), - { - "__module__": name, - "_target_name": target_name, - "_load_real_module": staticmethod(_load_real_module), - "__get_pydantic_core_schema__": classmethod(_core_schema), - "__get_pydantic_json_schema__": classmethod(_json_schema), - }, - ) + def __getattr__(self, attribute: str) -> Any: + fields = _load_real_module().GenerateContentConfig.model_fields + return getattr(fields[self.name], attribute) + + field_metadata: dict[str, Any] = {} + + def _generate_content_fields() -> dict[str, Any]: + if loaded: + return loaded[0].GenerateContentConfig.model_fields + if field_metadata: + return field_metadata + from pydantic.alias_generators import to_camel + + # ADK reads names and aliases for argument hints during import. Derive + # them from the installed SDK without executing its generated models. + source = Path(str(spec.origin)).read_text(encoding="utf-8") + for node in ast.parse(source).body: + if ( + not isinstance(node, ast.ClassDef) + or node.name != "GenerateContentConfig" + ): + continue + for field in node.body: + if not isinstance(field, ast.AnnAssign) or not isinstance( + field.target, ast.Name + ): + continue + field_name = field.target.id + alias = to_camel(field_name) + if isinstance(field.value, ast.Call): + for keyword in field.value.keywords: + if ( + keyword.arg == "alias" + and isinstance(keyword.value, ast.Constant) + and isinstance(keyword.value.value, str) + ): + alias = keyword.value.value + field_metadata[field_name] = _DeferredField(field_name, alias) + return field_metadata + raise ImportError("Unable to locate Google GenAI GenerateContentConfig fields") def _load_attribute(attribute: str) -> Any: if attribute.startswith("__"): raise AttributeError(f"module {name!r} has no attribute {attribute!r}") - value = _deferred_type(attribute) + value = _deferred_genai_type(attribute, name, _load_real_module) + if attribute == "GenerateContentConfig": + value._deferred_model_fields = staticmethod(_generate_content_fields) setattr(proxy, attribute, value) return value @@ -340,6 +390,12 @@ def _install_studio_genai_imports() -> None: "__version__": ("google.genai.version", "__version__"), }, ) + if "google.genai.client" not in sys.modules: + package.Client = _deferred_genai_type( + "Client", + "google.genai.client", + lambda: importlib.import_module("google.genai.client"), + ) types_module = _install_lazy_genai_types() setattr(package, "types", types_module) models_module = _install_lazy_genai_models() diff --git a/veadk/utils/patches.py b/veadk/utils/patches.py index f5e811e04..18b6ff3a4 100644 --- a/veadk/utils/patches.py +++ b/veadk/utils/patches.py @@ -98,6 +98,39 @@ def _set_parallel_run_code_context(tool, tool_context, max_workers: int | None) ) +def patch_adk_dynamic_agent_transfer() -> None: + """Resolve scheduler transfers against the agent instance that just ran.""" + if get_adk_version() < Version("2.8.0"): + return + + from google.adk.agents import BaseAgent + from google.adk.workflow import _dynamic_node_scheduler + from google.adk.workflow.utils import _transfer_utils + + original = _transfer_utils.resolve_and_derive_transfer_context + if getattr(original, "_veadk_dynamic_transfer_patch", False): + return + + @functools.wraps(original) + def resolve_transfer( + target_name, current_agent, root_agent, curr_ctx, curr_parent_ctx + ): + # The runner executes a clone but otherwise resolves against its template. + active_agent = getattr(curr_ctx, "node", None) + if isinstance(active_agent, BaseAgent): + current_agent = active_agent + root_agent = active_agent.root_agent + return original( + target_name, current_agent, root_agent, curr_ctx, curr_parent_ctx + ) + + resolve_transfer._veadk_dynamic_transfer_patch = True + _transfer_utils.resolve_and_derive_transfer_context = resolve_transfer + # ADK 2.8/2.9 import locally; 2.10/2.11 retain a module-level alias. + if hasattr(_dynamic_node_scheduler, "resolve_and_derive_transfer_context"): + _dynamic_node_scheduler.resolve_and_derive_transfer_context = resolve_transfer + + def patch_asyncio(): """Patch asyncio to ignore 'Event loop is closed' error. @@ -106,6 +139,7 @@ def patch_asyncio(): - https://github.com/google/adk-python/pull/1420 """ patch_adk_workflow_agent_mode() + patch_adk_dynamic_agent_transfer() original_del = asyncio.base_subprocess.BaseSubprocessTransport.__del__ @@ -242,19 +276,33 @@ def patch_tracer() -> None: def patch_adk_sync_tool_thread_pool() -> None: """Enable ADK's tool thread pool for non-live ``run_async`` tool calls. - Google ADK exposes ``RunConfig.tool_thread_pool_config`` and already has a - thread-pool helper for sync tools, but some supported versions only consult - that config in the live-tool path. VeADK agents use the standard async flow, - so sync tools such as builtin ``run_code`` would otherwise block the event - loop and serialize same-turn tool calls. + ADK before 2.11 needs the helper for both RunConfig and Agent defaults. ADK 2.11 + handles RunConfig natively, but still needs VeADK's Agent default and + parallel run_code session isolation. """ try: from google.adk.flows.llm_flows import functions as adk_functions + from google.adk.tools.function_tool import FunctionTool if getattr(adk_functions, "_veadk_sync_tool_thread_pool_patched", False): return - original_call_tool_async = getattr(adk_functions, "__call_tool_async") + adk_version = get_adk_version() + native_thread_pool = adk_version >= Version("2.11.0") + if adk_version >= Version("2.10.0"): + # The compatibility module only re-exports this function; patch its + # defining module so real Runner calls use it too. + from google.adk.flows.llm_flows.tools import _caller as call_module + + call_name = "_call_tool_async" + elif adk_version >= Version("2.9.0"): + from google.adk.flows.llm_flows import _tool_caller as call_module + + call_name = "_call_tool_async" + else: + call_module = adk_functions + call_name = "__call_tool_async" + original_call_tool_async = getattr(call_module, call_name) original_handle_function_call_list_async = getattr( adk_functions, "handle_function_call_list_async" ) @@ -270,7 +318,16 @@ async def veadk_call_tool_async(tool, args, tool_context): max_workers = _resolve_tool_thread_pool_max_workers(tool, tool_context) _set_parallel_run_code_context(tool, tool_context, max_workers) - if max_workers is not None: + invocation_context = getattr(tool_context, "_invocation_context", None) + run_config = getattr(invocation_context, "run_config", None) + uses_native_pool = native_thread_pool and ( + getattr(run_config, "tool_thread_pool_config", None) is not None + ) + sync_function_tool = isinstance(tool, FunctionTool) and ( + adk_functions._is_sync_tool(tool) + ) + # Async tools such as AgentTool must keep their caller's event loop. + if max_workers is not None and not uses_native_pool and sync_function_tool: return await call_tool_in_thread_pool( tool, args=args, @@ -312,7 +369,7 @@ async def veadk_handle_function_call_list_async( finally: _PARALLEL_RUN_CODE_CALL_COUNT.reset(token) - adk_functions.__call_tool_async = veadk_call_tool_async + setattr(call_module, call_name, veadk_call_tool_async) adk_functions.handle_function_call_list_async = ( veadk_handle_function_call_list_async )