google-adk 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

google/adk/cli/fast_api.py

@@ -13,16 +13,13 @@
 # limitations under the License.
 
 
+from __future__ import annotations
+
 import asyncio
 from contextlib import asynccontextmanager
-import importlib
-import inspect
-import json
 import logging
 import os
 from pathlib import Path
-import signal
-import sys
 import time
 import traceback
 import typing
@@ -55,15 +52,18 @@ from starlette.types import Lifespan
 from typing_extensions import override
 
 from ..agents import RunConfig
-from ..agents.base_agent import BaseAgent
 from ..agents.live_request_queue import LiveRequest
 from ..agents.live_request_queue import LiveRequestQueue
 from ..agents.llm_agent import Agent
-from ..agents.llm_agent import LlmAgent
 from ..agents.run_config import StreamingMode
-from ..artifacts import InMemoryArtifactService
+from ..artifacts.in_memory_artifact_service import InMemoryArtifactService
 from ..evaluation.eval_case import EvalCase
 from ..evaluation.eval_case import SessionInput
+from ..evaluation.eval_metrics import EvalMetric
+from ..evaluation.eval_metrics import EvalMetricResult
+from ..evaluation.eval_metrics import EvalMetricResultPerInvocation
+from ..evaluation.eval_result import EvalSetResult
+from ..evaluation.local_eval_set_results_manager import LocalEvalSetResultsManager
 from ..evaluation.local_eval_sets_manager import LocalEvalSetsManager
 from ..events.event import Event
 from ..memory.in_memory_memory_service import InMemoryMemoryService
@@ -72,23 +72,18 @@ from ..sessions.database_session_service import DatabaseSessionService
 from ..sessions.in_memory_session_service import InMemorySessionService
 from ..sessions.session import Session
 from ..sessions.vertex_ai_session_service import VertexAiSessionService
-from ..tools.base_toolset import BaseToolset
 from .cli_eval import EVAL_SESSION_ID_PREFIX
-from .cli_eval import EvalCaseResult
-from .cli_eval import EvalMetric
-from .cli_eval import EvalMetricResult
-from .cli_eval import EvalMetricResultPerInvocation
-from .cli_eval import EvalSetResult
 from .cli_eval import EvalStatus
+from .utils import cleanup
 from .utils import common
 from .utils import create_empty_state
 from .utils import envs
 from .utils import evals
+from .utils.agent_loader import AgentLoader
 
 logger = logging.getLogger("google_adk." + __name__)
 
 _EVAL_SET_FILE_EXTENSION = ".evalset.json"
-_EVAL_SET_RESULT_FILE_EXTENSION = ".evalset_result.json"
 
 
 class ApiServerSpanExporter(export.SpanExporter):
@@ -196,7 +191,7 @@ class GetEventGraphResult(common.BaseModel):
 
 def get_fast_api_app(
     *,
-    agent_dir: str,
+    agents_dir: str,
     session_db_url: str = "",
     allow_origins: Optional[list[str]] = None,
     web: bool,
@@ -215,7 +210,7 @@ def get_fast_api_app(
   memory_exporter = InMemoryExporter(session_trace_dict)
   provider.add_span_processor(export.SimpleSpanProcessor(memory_exporter))
   if trace_to_cloud:
-    envs.load_dotenv_for_agent("", agent_dir)
+    envs.load_dotenv_for_agent("", agents_dir)
     if project_id := os.environ.get("GOOGLE_CLOUD_PROJECT", None):
       processor = export.BatchSpanProcessor(
           CloudTraceSpanExporter(project_id=project_id)
@@ -229,27 +224,8 @@ def get_fast_api_app(
 
   trace.set_tracer_provider(provider)
 
-  toolsets_to_close: set[BaseToolset] = set()
-
   @asynccontextmanager
   async def internal_lifespan(app: FastAPI):
-    # Set up signal handlers for graceful shutdown
-    original_sigterm = signal.getsignal(signal.SIGTERM)
-    original_sigint = signal.getsignal(signal.SIGINT)
-
-    def cleanup_handler(sig, frame):
-      # Log the signal
-      logger.info("Received signal %s, performing pre-shutdown cleanup", sig)
-      # Do synchronous cleanup if needed
-      # Then call original handler if it exists
-      if sig == signal.SIGTERM and callable(original_sigterm):
-        original_sigterm(sig, frame)
-      elif sig == signal.SIGINT and callable(original_sigint):
-        original_sigint(sig, frame)
-
-    # Install cleanup handlers
-    signal.signal(signal.SIGTERM, cleanup_handler)
-    signal.signal(signal.SIGINT, cleanup_handler)
 
     try:
       if lifespan:
@@ -258,46 +234,8 @@ def get_fast_api_app(
       else:
         yield
     finally:
-      # During shutdown, properly clean up all toolsets
-      logger.info(
-          "Server shutdown initiated, cleaning up %s toolsets",
-          len(toolsets_to_close),
-      )
-
-      # Create tasks for all toolset closures to run concurrently
-      cleanup_tasks = []
-      for toolset in toolsets_to_close:
-        task = asyncio.create_task(close_toolset_safely(toolset))
-        cleanup_tasks.append(task)
-
-      if cleanup_tasks:
-        # Wait for all cleanup tasks with timeout
-        done, pending = await asyncio.wait(
-            cleanup_tasks,
-            timeout=10.0,  # 10 second timeout for cleanup
-            return_when=asyncio.ALL_COMPLETED,
-        )
-
-        # If any tasks are still pending, log it
-        if pending:
-          logger.warning(
-              f"{len(pending)} toolset cleanup tasks didn't complete in time"
-          )
-          for task in pending:
-            task.cancel()
-
-      # Restore original signal handlers
-      signal.signal(signal.SIGTERM, original_sigterm)
-      signal.signal(signal.SIGINT, original_sigint)
-
-  async def close_toolset_safely(toolset):
-    """Safely close a toolset with error handling."""
-    try:
-      logger.info(f"Closing toolset: {type(toolset).__name__}")
-      await toolset.close()
-      logger.info(f"Successfully closed toolset: {type(toolset).__name__}")
-    except Exception as e:
-      logger.error(f"Error closing toolset {type(toolset).__name__}: {e}")
+      # Create tasks for all runner closures to run concurrently
+      await cleanup.close_runners(list(runner_dict.values()))
 
   # Run the FastAPI server.
   app = FastAPI(lifespan=internal_lifespan)
@@ -311,17 +249,14 @@ def get_fast_api_app(
         allow_headers=["*"],
     )
 
-  if agent_dir not in sys.path:
-    sys.path.append(agent_dir)
-
   runner_dict = {}
-  root_agent_dict = {}
 
   # Build the Artifact service
   artifact_service = InMemoryArtifactService()
   memory_service = InMemoryMemoryService()
 
-  eval_sets_manager = LocalEvalSetsManager(agent_dir=agent_dir)
+  eval_sets_manager = LocalEvalSetsManager(agents_dir=agents_dir)
+  eval_set_results_manager = LocalEvalSetResultsManager(agents_dir=agents_dir)
 
   # Build the Session service
   agent_engine_id = ""
@@ -331,7 +266,7 @@ def get_fast_api_app(
       agent_engine_id = session_db_url.split("://")[1]
       if not agent_engine_id:
         raise click.ClickException("Agent engine id can not be empty.")
-      envs.load_dotenv_for_agent("", agent_dir)
+      envs.load_dotenv_for_agent("", agents_dir)
       session_service = VertexAiSessionService(
           os.environ["GOOGLE_CLOUD_PROJECT"],
           os.environ["GOOGLE_CLOUD_LOCATION"],
@@ -341,9 +276,12 @@ def get_fast_api_app(
   else:
     session_service = InMemorySessionService()
 
+  # initialize Agent Loader
+  agent_loader = AgentLoader(agents_dir)
+
   @app.get("/list-apps")
   def list_apps() -> list[str]:
-    base_path = Path.cwd() / agent_dir
+    base_path = Path.cwd() / agents_dir
     if not base_path.exists():
       raise HTTPException(status_code=404, detail="Path not found")
     if not base_path.is_dir():
@@ -459,9 +397,9 @@ def get_fast_api_app(
         app_name=app_name, user_id=user_id, state=state
     )
 
-  def _get_eval_set_file_path(app_name, agent_dir, eval_set_id) -> str:
+  def _get_eval_set_file_path(app_name, agents_dir, eval_set_id) -> str:
     return os.path.join(
-        agent_dir,
+        agents_dir,
         app_name,
         eval_set_id + _EVAL_SET_FILE_EXTENSION,
     )
@@ -509,7 +447,7 @@ def get_fast_api_app(
 
     # Populate the session with initial session state.
     initial_session_state = create_empty_state(
-        await _get_root_agent_async(app_name)
+        agent_loader.load_agent(app_name)
     )
 
     new_eval_case = EvalCase(
@@ -551,8 +489,6 @@ def get_fast_api_app(
 
     # Create a mapping from eval set file to all the evals that needed to be
     # run.
-    envs.load_dotenv_for_agent(os.path.basename(app_name), agent_dir)
-
     eval_set = eval_sets_manager.get_eval_set(app_name, eval_set_id)
 
     if req.eval_ids:
@@ -562,7 +498,7 @@ def get_fast_api_app(
       logger.info("Eval ids to run list is empty. We will run all eval cases.")
       eval_set_to_evals = {eval_set_id: eval_set.eval_cases}
 
-    root_agent = await _get_root_agent_async(app_name)
+    root_agent = agent_loader.load_agent(app_name)
     run_eval_results = []
     eval_case_results = []
     async for eval_case_result in run_evals(
@@ -594,32 +530,10 @@ def get_fast_api_app(
       )
       eval_case_results.append(eval_case_result)
 
-    timestamp = time.time()
-    eval_set_result_name = app_name + "_" + eval_set_id + "_" + str(timestamp)
-    eval_set_result = EvalSetResult(
-        eval_set_result_id=eval_set_result_name,
-        eval_set_result_name=eval_set_result_name,
-        eval_set_id=eval_set_id,
-        eval_case_results=eval_case_results,
-        creation_timestamp=timestamp,
+    eval_set_results_manager.save_eval_set_result(
+        app_name, eval_set_id, eval_case_results
     )
 
-    # Write eval result file, with eval_set_result_name.
-    app_eval_history_dir = os.path.join(
-        agent_dir, app_name, ".adk", "eval_history"
-    )
-    if not os.path.exists(app_eval_history_dir):
-      os.makedirs(app_eval_history_dir)
-    # Convert to json and write to file.
-    eval_set_result_json = eval_set_result.model_dump_json()
-    eval_set_result_file_path = os.path.join(
-        app_eval_history_dir,
-        eval_set_result_name + _EVAL_SET_RESULT_FILE_EXTENSION,
-    )
-    logger.info("Writing eval result to file: %s", eval_set_result_file_path)
-    with open(eval_set_result_file_path, "w") as f:
-      f.write(json.dumps(eval_set_result_json, indent=2))
-
     return run_eval_results
 
   @app.get(
@@ -631,25 +545,14 @@ def get_fast_api_app(
       eval_result_id: str,
   ) -> EvalSetResult:
     """Gets the eval result for the given eval id."""
-    # Load the eval set file data
-    maybe_eval_result_file_path = (
-        os.path.join(
-            agent_dir, app_name, ".adk", "eval_history", eval_result_id
-        )
-        + _EVAL_SET_RESULT_FILE_EXTENSION
-    )
-    if not os.path.exists(maybe_eval_result_file_path):
-      raise HTTPException(
-          status_code=404,
-          detail=f"Eval result `{eval_result_id}` not found.",
-      )
-    with open(maybe_eval_result_file_path, "r") as file:
-      eval_result_data = json.load(file)  # Load JSON into a list
     try:
-      eval_result = EvalSetResult.model_validate_json(eval_result_data)
-      return eval_result
-    except ValidationError as e:
-      logger.exception("get_eval_result validation error: %s", e)
+      return eval_set_results_manager.get_eval_set_result(
+          app_name, eval_result_id
+      )
+    except ValueError as ve:
+      raise HTTPException(status_code=404, detail=str(ve)) from ve
+    except ValidationError as ve:
+      raise HTTPException(status_code=500, detail=str(ve)) from ve
 
   @app.get(
       "/apps/{app_name}/eval_results",
@@ -657,19 +560,7 @@ def get_fast_api_app(
   )
   def list_eval_results(app_name: str) -> list[str]:
     """Lists all eval results for the given app."""
-    app_eval_history_directory = os.path.join(
-        agent_dir, app_name, ".adk", "eval_history"
-    )
-
-    if not os.path.exists(app_eval_history_directory):
-      return []
-
-    eval_result_files = [
-        file.removesuffix(_EVAL_SET_RESULT_FILE_EXTENSION)
-        for file in os.listdir(app_eval_history_directory)
-        if file.endswith(_EVAL_SET_RESULT_FILE_EXTENSION)
-    ]
-    return eval_result_files
+    return eval_set_results_manager.list_eval_set_results(app_name)
 
   @app.delete("/apps/{app_name}/users/{user_id}/sessions/{session_id}")
   async def delete_session(app_name: str, user_id: str, session_id: str):
@@ -769,9 +660,9 @@ def get_fast_api_app(
   @app.post("/run", response_model_exclude_none=True)
   async def agent_run(req: AgentRunRequest) -> list[Event]:
     # Connect to managed session if agent_engine_id is set.
-    app_id = agent_engine_id if agent_engine_id else req.app_name
+    app_name = agent_engine_id if agent_engine_id else req.app_name
     session = await session_service.get_session(
-        app_name=app_id, user_id=req.user_id, session_id=req.session_id
+        app_name=app_name, user_id=req.user_id, session_id=req.session_id
     )
     if not session:
       raise HTTPException(status_code=404, detail="Session not found")
@@ -790,10 +681,10 @@ def get_fast_api_app(
   @app.post("/run_sse")
   async def agent_run_sse(req: AgentRunRequest) -> StreamingResponse:
     # Connect to managed session if agent_engine_id is set.
-    app_id = agent_engine_id if agent_engine_id else req.app_name
+    app_name = agent_engine_id if agent_engine_id else req.app_name
     # SSE endpoint
     session = await session_service.get_session(
-        app_name=app_id, user_id=req.user_id, session_id=req.session_id
+        app_name=app_name, user_id=req.user_id, session_id=req.session_id
     )
     if not session:
       raise HTTPException(status_code=404, detail="Session not found")
@@ -832,9 +723,9 @@ def get_fast_api_app(
       app_name: str, user_id: str, session_id: str, event_id: str
   ):
     # Connect to managed session if agent_engine_id is set.
-    app_id = agent_engine_id if agent_engine_id else app_name
+    app_name = agent_engine_id if agent_engine_id else app_name
     session = await session_service.get_session(
-        app_name=app_id, user_id=user_id, session_id=session_id
+        app_name=app_name, user_id=user_id, session_id=session_id
     )
     session_events = session.events if session else []
     event = next((x for x in session_events if x.id == event_id), None)
@@ -845,7 +736,7 @@ def get_fast_api_app(
 
     function_calls = event.get_function_calls()
     function_responses = event.get_function_responses()
-    root_agent = await _get_root_agent_async(app_name)
+    root_agent = agent_loader.load_agent(app_name)
     dot_graph = None
     if function_calls:
       function_call_highlights = []
@@ -889,9 +780,9 @@ def get_fast_api_app(
     await websocket.accept()
 
     # Connect to managed session if agent_engine_id is set.
-    app_id = agent_engine_id if agent_engine_id else app_name
+    app_name = agent_engine_id if agent_engine_id else app_name
     session = await session_service.get_session(
-        app_name=app_id, user_id=user_id, session_id=session_id
+        app_name=app_name, user_id=user_id, session_id=session_id
     )
     if not session:
       # Accept first so that the client is aware of connection establishment,
@@ -946,36 +837,12 @@ def get_fast_api_app(
       for task in pending:
         task.cancel()
 
-  def _get_all_toolsets(agent: BaseAgent) -> set[BaseToolset]:
-    toolsets = set()
-    if isinstance(agent, LlmAgent):
-      for tool_union in agent.tools:
-        if isinstance(tool_union, BaseToolset):
-          toolsets.add(tool_union)
-    for sub_agent in agent.sub_agents:
-      toolsets.update(_get_all_toolsets(sub_agent))
-    return toolsets
-
-  async def _get_root_agent_async(app_name: str) -> Agent:
-    """Returns the root agent for the given app."""
-    if app_name in root_agent_dict:
-      return root_agent_dict[app_name]
-    agent_module = importlib.import_module(app_name)
-    if getattr(agent_module.agent, "root_agent"):
-      root_agent = agent_module.agent.root_agent
-    else:
-      raise ValueError(f'Unable to find "root_agent" from {app_name}.')
-
-    root_agent_dict[app_name] = root_agent
-    toolsets_to_close.update(_get_all_toolsets(root_agent))
-    return root_agent
-
   async def _get_runner_async(app_name: str) -> Runner:
     """Returns the runner for the given app."""
-    envs.load_dotenv_for_agent(os.path.basename(app_name), agent_dir)
+    envs.load_dotenv_for_agent(os.path.basename(app_name), agents_dir)
     if app_name in runner_dict:
       return runner_dict[app_name]
-    root_agent = await _get_root_agent_async(app_name)
+    root_agent = agent_loader.load_agent(app_name)
     runner = Runner(
         app_name=agent_engine_id if agent_engine_id else app_name,
         agent=root_agent,
@@ -991,14 +858,16 @@ def get_fast_api_app(
     ANGULAR_DIST_PATH = BASE_DIR / "browser"
 
     @app.get("/")
-    async def redirect_to_dev_ui():
-      return RedirectResponse("/dev-ui")
+    async def redirect_root_to_dev_ui():
+      return RedirectResponse("/dev-ui/")
 
     @app.get("/dev-ui")
-    async def dev_ui():
-      return FileResponse(BASE_DIR / "browser/index.html")
+    async def redirect_dev_ui_add_slash():
+      return RedirectResponse("/dev-ui/")
 
     app.mount(
-        "/", StaticFiles(directory=ANGULAR_DIST_PATH, html=True), name="static"
+        "/dev-ui/",
+        StaticFiles(directory=ANGULAR_DIST_PATH, html=True),
+        name="static",
     )
   return app

google/adk/cli/utils/agent_loader.py

@@ -0,0 +1,137 @@
+# Copyright 2025 Google LLC
+#
+# 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.
+
+from __future__ import annotations
+
+import importlib
+import logging
+import sys
+
+from . import envs
+from ...agents.base_agent import BaseAgent
+
+logger = logging.getLogger("google_adk." + __name__)
+
+
+class AgentLoader:
+  """Centralized agent loading with proper isolation, caching, and .env loading.
+  Support loading agents from below folder/file structures:
+  a) agents_dir/agent_name.py (with root_agent or agent.root_agent in it)
+  b) agents_dir/agent_name_folder/__init__.py (with root_agent or agent.root_agent in the package)
+  c) agents_dir/agent_name_folder/agent.py (where agent.py has root_agent)
+  """
+
+  def __init__(self, agents_dir: str):
+    self.agents_dir = agents_dir.rstrip("/")
+    self._original_sys_path = None
+    self._agent_cache: dict[str, BaseAgent] = {}
+
+  def _load_from_module_or_package(self, agent_name: str) -> BaseAgent:
+    # Load for case: Import "<agent_name>" (as a package or module)
+    # Covers structures:
+    #   a) agents_dir/agent_name.py (with root_agent or agent.root_agent in it)
+    #   b) agents_dir/agent_name_folder/__init__.py (with root_agent or agent.root_agent in the package)
+    try:
+      module_candidate = importlib.import_module(agent_name)
+      # Check for "root_agent" directly in "<agent_name>" module/package
+      if hasattr(module_candidate, "root_agent"):
+        logger.debug("Found root_agent directly in %s", agent_name)
+        return module_candidate.root_agent
+      # Check for "<agent_name>.agent.root_agent" structure (e.g. agent_name is a package,
+      # and it has an 'agent' submodule/attribute which in turn has 'root_agent')
+      if hasattr(module_candidate, "agent") and hasattr(
+          module_candidate.agent, "root_agent"
+      ):
+        logger.debug("Found root_agent in %s.agent attribute", agent_name)
+        if isinstance(module_candidate.agent, BaseAgent):
+          return module_candidate.agent.root_agent
+        else:
+          logger.warning(
+              "Root agent found is not an instance of BaseAgent. But a type %s",
+              type(module_candidate.agent),
+          )
+    except ModuleNotFoundError:
+      logger.debug("Module %s itself not found.", agent_name)
+      # Re-raise as ValueError to be caught by the final error message construction
+      raise ValueError(
+          f"Module {agent_name} not found during import attempts."
+      ) from None
+    except ImportError as e:
+      logger.warning("Error importing %s: %s", agent_name, e)
+
+    return None
+
+  def _load_from_submodule(self, agent_name: str) -> BaseAgent:
+    # Load for case: Import "<agent_name>.agent" and look for "root_agent"
+    # Covers structure: agents_dir/agent_name_folder/agent.py (where agent.py has root_agent)
+    try:
+      module_candidate = importlib.import_module(f"{agent_name}.agent")
+      if hasattr(module_candidate, "root_agent"):
+        logger.debug("Found root_agent in %s.agent", agent_name)
+        if isinstance(module_candidate.root_agent, BaseAgent):
+          return module_candidate.root_agent
+        else:
+          logger.warning(
+              "Root agent found is not an instance of BaseAgent. But a type %s",
+              type(module_candidate.root_agent),
+          )
+    except ModuleNotFoundError:
+      logger.debug(
+          "Module %s.agent not found, trying next pattern.", agent_name
+      )
+    except ImportError as e:
+      logger.warning("Error importing %s.agent: %s", agent_name, e)
+
+    return None
+
+  def _perform_load(self, agent_name: str) -> BaseAgent:
+    """Internal logic to load an agent"""
+    # Add self.agents_dir to sys.path
+    if self.agents_dir not in sys.path:
+      sys.path.insert(0, self.agents_dir)
+
+    logger.debug(
+        "Loading .env for agent %s from %s", agent_name, self.agents_dir
+    )
+    envs.load_dotenv_for_agent(agent_name, str(self.agents_dir))
+
+    root_agent = self._load_from_module_or_package(agent_name)
+    if root_agent:
+      return root_agent
+
+    root_agent = self._load_from_submodule(agent_name)
+    if root_agent:
+      return root_agent
+
+    # If no root_agent was found by any pattern
+    raise ValueError(
+        f"No root_agent found for '{agent_name}'. Searched in"
+        f" '{agent_name}.agent.root_agent', '{agent_name}.root_agent', and"
+        f" via an 'agent' attribute within the '{agent_name}' module/package."
+        f" Ensure '{self.agents_dir}/{agent_name}' is structured correctly,"
+        " an .env file can be loaded if present, and a root_agent is"
+        " exposed."
+    )
+
+  def load_agent(self, agent_name: str) -> BaseAgent:
+    """Load an agent module (with caching & .env) and return its root_agent (asynchronously)."""
+    if agent_name in self._agent_cache:
+      logger.debug("Returning cached agent for %s (async)", agent_name)
+      return self._agent_cache[agent_name]
+
+    logger.debug("Loading agent %s - not in cache.", agent_name)
+    # Assumes this method is called when the context manager (`with self:`) is active
+    agent = self._perform_load(agent_name)
+    self._agent_cache[agent_name] = agent
+    return agent

google/adk/cli/utils/cleanup.py

@@ -0,0 +1,40 @@
+# Copyright 2025 Google LLC
+#
+# 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.
+
+import asyncio
+import logging
+from typing import List
+
+from ...runners import Runner
+
+logger = logging.getLogger("google_adk." + __name__)
+
+
+async def close_runners(runners: List[Runner]) -> None:
+  cleanup_tasks = [asyncio.create_task(runner.close()) for runner in runners]
+  if cleanup_tasks:
+    # Wait for all cleanup tasks with timeout
+    done, pending = await asyncio.wait(
+        cleanup_tasks,
+        timeout=30.0,  # 30 second timeout for cleanup
+        return_when=asyncio.ALL_COMPLETED,
+    )
+
+    # If any tasks are still pending, log it
+    if pending:
+      logger.warning(
+          "%s runner close tasks didn't complete in time", len(pending)
+      )
+      for task in pending:
+        task.cancel()

google/adk/cli/utils/evals.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Tuple
+from typing import Any
+from typing import Tuple
 
 from deprecated import deprecated
 from google.genai import types as genai_types

google/adk/cli/utils/logs.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import logging
 import os
-import sys
 import tempfile
 import time
 
@@ -27,14 +28,8 @@ def setup_adk_logger(level=logging.INFO):
   # Configure the root logger format and level.
   logging.basicConfig(level=level, format=LOGGING_FORMAT)
 
-  # Set up adk_logger and log to stderr.
-  handler = logging.StreamHandler(sys.stderr)
-  handler.setLevel(level)
-  handler.setFormatter(logging.Formatter(LOGGING_FORMAT))
-
   adk_logger = logging.getLogger('google_adk')
   adk_logger.setLevel(level)
-  adk_logger.addHandler(handler)
 
 
 def log_to_tmp_folder(

google/adk/code_executors/code_execution_utils.py

@@ -19,7 +19,8 @@ import binascii
 import copy
 import dataclasses
 import re
-from typing import List, Optional
+from typing import List
+from typing import Optional
 
 from google.genai import types
 

google/adk/code_executors/container_code_executor.py

@@ -27,7 +27,6 @@ from .base_code_executor import BaseCodeExecutor
 from .code_execution_utils import CodeExecutionInput
 from .code_execution_utils import CodeExecutionResult
 
-
 DEFAULT_IMAGE_TAG = 'adk-code-executor:latest'