google-adk 0.5.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

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/common.py

@@ -0,0 +1,23 @@
+# 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 pydantic
+from pydantic import alias_generators
+
+
+class BaseModel(pydantic.BaseModel):
+  model_config = pydantic.ConfigDict(
+      alias_generator=alias_generators.to_camel,
+      populate_by_name=True,
+  )

google/adk/cli/utils/evals.py

@@ -13,10 +13,17 @@
 # limitations under the License.
 
 from typing import Any
+from typing import Tuple
 
+from deprecated import deprecated
+from google.genai import types as genai_types
+
+from ...evaluation.eval_case import IntermediateData
+from ...evaluation.eval_case import Invocation
 from ...sessions.session import Session
 
 
+@deprecated(reason='Use convert_session_to_eval_invocations instead.')
 def convert_session_to_eval_format(session: Session) -> list[dict[str, Any]]:
   """Converts a session data into eval format.
 
@@ -91,3 +98,79 @@ def convert_session_to_eval_format(session: Session) -> list[dict[str, Any]]:
       })
 
   return eval_case
+
+
+def convert_session_to_eval_invocations(session: Session) -> list[Invocation]:
+  """Converts a session data into a list of Invocation.
+
+  Args:
+      session: The session that should be converted.
+
+  Returns:
+      list: A list of invocation.
+  """
+  invocations: list[Invocation] = []
+  events = session.events if session and session.events else []
+
+  for event in events:
+    if event.author == 'user':
+      if not event.content or not event.content.parts:
+        continue
+
+      # The content present in this event is the user content.
+      user_content = event.content
+      invocation_id = event.invocation_id
+      invocaton_timestamp = event.timestamp
+
+      # Find the corresponding tool usage or response for the query
+      tool_uses: list[genai_types.FunctionCall] = []
+      intermediate_responses: list[Tuple[str, list[genai_types.Part]]] = []
+
+      # Check subsequent events to extract tool uses or responses for this turn.
+      for subsequent_event in events[events.index(event) + 1 :]:
+        event_author = subsequent_event.author or 'agent'
+        if event_author == 'user':
+          # We found an event where the author was the user. This means that a
+          # new turn has started. So close this turn here.
+          break
+
+        if not subsequent_event.content or not subsequent_event.content.parts:
+          continue
+
+        intermediate_response_parts = []
+        for subsequent_part in subsequent_event.content.parts:
+          # Some events have both function call and reference
+          if subsequent_part.function_call:
+            tool_uses.append(subsequent_part.function_call)
+          elif subsequent_part.text:
+            # Also keep track of all the natural language responses that
+            # agent (or sub agents) generated.
+            intermediate_response_parts.append(subsequent_part)
+
+        if intermediate_response_parts:
+          # Only add an entry if there any intermediate entries.
+          intermediate_responses.append(
+              (event_author, intermediate_response_parts)
+          )
+
+      # If we are here then either we are done reading all the events or we
+      # encountered an event that had content authored by the end-user.
+      # This, basically means an end of turn.
+      # We assume that the last natural language intermediate response is the
+      # final response from the agent/model. We treat that as a reference.
+      invocations.append(
+          Invocation(
+              user_content=user_content,
+              invocation_id=invocation_id,
+              creation_timestamp=invocaton_timestamp,
+              intermediate_data=IntermediateData(
+                  tool_uses=tool_uses,
+                  intermediate_responses=intermediate_responses[:-1],
+              ),
+              final_response=genai_types.Content(
+                  parts=intermediate_responses[-1][1]
+              ),
+          )
+      )
+
+  return invocations

google/adk/cli/utils/logs.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import logging
 import os
 import tempfile
@@ -22,11 +24,12 @@ LOGGING_FORMAT = (
 )
 
 
-def log_to_stderr(level=logging.INFO):
-  logging.basicConfig(
-      level=level,
-      format=LOGGING_FORMAT,
-  )
+def setup_adk_logger(level=logging.INFO):
+  # Configure the root logger format and level.
+  logging.basicConfig(level=level, format=LOGGING_FORMAT)
+
+  adk_logger = logging.getLogger('google_adk')
+  adk_logger.setLevel(level)
 
 
 def log_to_tmp_folder(

google/adk/code_executors/__init__.py

@@ -15,13 +15,15 @@
 import logging
 
 from .base_code_executor import BaseCodeExecutor
+from .built_in_code_executor import BuiltInCodeExecutor
 from .code_executor_context import CodeExecutorContext
 from .unsafe_local_code_executor import UnsafeLocalCodeExecutor
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('google_adk.' + __name__)
 
 __all__ = [
     'BaseCodeExecutor',
+    'BuiltInCodeExecutor',
     'CodeExecutorContext',
     'UnsafeLocalCodeExecutor',
 ]

google/adk/code_executors/built_in_code_executor.py

@@ -0,0 +1,52 @@
+# 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 google.genai import types
+from typing_extensions import override
+
+from ..agents.invocation_context import InvocationContext
+from ..models import LlmRequest
+from .base_code_executor import BaseCodeExecutor
+from .code_execution_utils import CodeExecutionInput
+from .code_execution_utils import CodeExecutionResult
+
+
+class BuiltInCodeExecutor(BaseCodeExecutor):
+  """A code executor that uses the Model's built-in code executor.
+
+  Currently only supports Gemini 2.0+ models, but will be expanded to
+  other models.
+  """
+
+  @override
+  def execute_code(
+      self,
+      invocation_context: InvocationContext,
+      code_execution_input: CodeExecutionInput,
+  ) -> CodeExecutionResult:
+    pass
+
+  def process_llm_request(self, llm_request: LlmRequest) -> None:
+    """Pre-process the LLM request for Gemini 2.0+ models to use the code execution tool."""
+    if llm_request.model and llm_request.model.startswith("gemini-2"):
+      llm_request.config = llm_request.config or types.GenerateContentConfig()
+      llm_request.config.tools = llm_request.config.tools or []
+      llm_request.config.tools.append(
+          types.Tool(code_execution=types.ToolCodeExecution())
+      )
+      return
+    raise ValueError(
+        "Gemini code execution tool is not supported for model"
+        f" {llm_request.model}"
+    )

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'
 
 

google/adk/code_executors/vertex_ai_code_executor.py

@@ -15,7 +15,8 @@
 import datetime
 import mimetypes
 import os
-from typing import Any, Optional
+from typing import Any
+from typing import Optional
 
 from typing_extensions import override
 from vertexai.preview.extensions import Extension
@@ -147,18 +148,15 @@ class VertexAiCodeExecutor(BaseCodeExecutor):
     )
 
     # Save output file as artifacts.
-    current_timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-    file_name_prefix = '%s_' % str(current_timestamp)
     saved_files = []
     file_count = 0
     for output_file in code_execution_result['output_files']:
       file_type = output_file['name'].split('.')[-1]
-      file_name = file_name_prefix + '%d.%s' % (file_count, file_type)
       if file_type in _SUPPORTED_IMAGE_TYPES:
         file_count += 1
         saved_files.append(
             File(
-                name='plot_' + file_name,
+                name=output_file['name'],
                 content=output_file['contents'],
                 mime_type=f'image/{file_type}',
             )
@@ -167,16 +165,16 @@ class VertexAiCodeExecutor(BaseCodeExecutor):
         file_count += 1
         saved_files.append(
             File(
-                name='data_' + file_name,
+                name=output_file['name'],
                 content=output_file['contents'],
                 mime_type=f'text/{file_type}',
             )
         )
       else:
-        mime_type, _ = mimetypes.guess_type(file_name)
+        mime_type, _ = mimetypes.guess_type(output_file['name'])
         saved_files.append(
             File(
-                name=file_name,
+                name=output_file['name'],
                 content=output_file['contents'],
                 mime_type=mime_type,
             )

google/adk/evaluation/__init__.py

@@ -14,7 +14,7 @@
 
 import logging
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('google_adk.' + __name__)
 
 __all__ = []