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

google/adk/cli/fast_api.py.orig

@@ -13,7 +13,9 @@
 # limitations under the License.
 
 import asyncio
+from contextlib import asynccontextmanager
 import importlib
+import inspect
 import json
 import logging
 import os
@@ -28,10 +30,10 @@ from typing import Literal
 from typing import Optional
 
 import click
+from click import Tuple
 from fastapi import FastAPI
 from fastapi import HTTPException
 from fastapi import Query
-from fastapi import Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.responses import RedirectResponse
@@ -40,6 +42,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.websockets import WebSocket
 from fastapi.websockets import WebSocketDisconnect
 from google.genai import types
+import graphviz
 from opentelemetry import trace
 from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
 from opentelemetry.sdk.trace import export
@@ -47,6 +50,7 @@ from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace import TracerProvider
 from pydantic import BaseModel
 from pydantic import ValidationError
+from starlette.types import Lifespan
 
 from ..agents import RunConfig
 from ..agents.live_request_queue import LiveRequest
@@ -55,6 +59,7 @@ from ..agents.llm_agent import Agent
 from ..agents.run_config import StreamingMode
 from ..artifacts import InMemoryArtifactService
 from ..events.event import Event
+from ..memory.in_memory_memory_service import InMemoryMemoryService
 from ..runners import Runner
 from ..sessions.database_session_service import DatabaseSessionService
 from ..sessions.in_memory_session_service import InMemorySessionService
@@ -82,11 +87,16 @@ class ApiServerSpanExporter(export.SpanExporter):
       self, spans: typing.Sequence[ReadableSpan]
   ) -> export.SpanExportResult:
     for span in spans:
-      if span.name == "call_llm" or span.name == "send_data":
+      if (
+          span.name == "call_llm"
+          or span.name == "send_data"
+          or span.name.startswith("tool_response")
+      ):
         attributes = dict(span.attributes)
         attributes["trace_id"] = span.get_span_context().trace_id
         attributes["span_id"] = span.get_span_context().span_id
-        self.trace_dict[attributes["gcp.vertex.agent.event_id"]] = attributes
+        if attributes.get("gcp.vertex.agent.event_id", None):
+          self.trace_dict[attributes["gcp.vertex.agent.event_id"]] = attributes
     return export.SpanExportResult.SUCCESS
 
   def force_flush(self, timeout_millis: int = 30000) -> bool:
@@ -126,6 +136,8 @@ def get_fast_api_app(
     session_db_url: str = "",
     allow_origins: Optional[list[str]] = None,
     web: bool,
+    trace_to_cloud: bool = False,
+    lifespan: Optional[Lifespan[FastAPI]] = None,
 ) -> FastAPI:
   # InMemory tracing dict.
   trace_dict: dict[str, Any] = {}
@@ -135,26 +147,37 @@ def get_fast_api_app(
   provider.add_span_processor(
       export.SimpleSpanProcessor(ApiServerSpanExporter(trace_dict))
   )
-  if os.environ.get("ADK_TRACE_TO_CLOUD", "0") == "1":
-    processor = export.BatchSpanProcessor(
-        CloudTraceSpanExporter(
-            project_id=os.environ.get("GOOGLE_CLOUD_PROJECT", "")
-        )
-    )
-    provider.add_span_processor(processor)
+  if trace_to_cloud:
+    envs.load_dotenv_for_agent("", agent_dir)
+    if project_id := os.environ.get("GOOGLE_CLOUD_PROJECT", None):
+      processor = export.BatchSpanProcessor(
+          CloudTraceSpanExporter(project_id=project_id)
+      )
+      provider.add_span_processor(processor)
+    else:
+      logging.warning(
+          "GOOGLE_CLOUD_PROJECT environment variable is not set. Tracing will"
+          " not be enabled."
+      )
 
   trace.set_tracer_provider(provider)
 
+  exit_stacks = []
+
+  @asynccontextmanager
+  async def internal_lifespan(app: FastAPI):
+    if lifespan:
+      async with lifespan(app) as lifespan_context:
+        yield
+
+        if exit_stacks:
+          for stack in exit_stacks:
+            await stack.aclose()
+    else:
+      yield
+
   # Run the FastAPI server.
-  app = FastAPI()
-  origins = ["http://localhost:4200"]
-  app.add_middleware(
-      CORSMiddleware,
-      allow_origins=origins,
-      allow_credentials=True,
-      allow_methods=["*"],
-      allow_headers=["*"],
-  )
+  app = FastAPI(lifespan=internal_lifespan)
 
   if allow_origins:
     app.add_middleware(
@@ -173,6 +196,7 @@ def get_fast_api_app(
 
   # Build the Artifact service
   artifact_service = InMemoryArtifactService()
+  memory_service = InMemoryMemoryService()
 
   # Build the Session service
   agent_engine_id = ""
@@ -223,7 +247,9 @@ def get_fast_api_app(
   def get_session(app_name: str, user_id: str, session_id: str) -> Session:
     # Connect to managed session if agent_engine_id is set.
     app_name = agent_engine_id if agent_engine_id else app_name
-    session = session_service.get_session(app_name, user_id, session_id)
+    session = session_service.get_session(
+        app_name=app_name, user_id=user_id, session_id=session_id
+    )
     if not session:
       raise HTTPException(status_code=404, detail="Session not found")
     return session
@@ -237,7 +263,9 @@ def get_fast_api_app(
     app_name = agent_engine_id if agent_engine_id else app_name
     return [
         session
-        for session in session_service.list_sessions(app_name, user_id).sessions
+        for session in session_service.list_sessions(
+            app_name=app_name, user_id=user_id
+        ).sessions
         # Remove sessions that were generated as a part of Eval.
         if not session.id.startswith(EVAL_SESSION_ID_PREFIX)
     ]
@@ -246,7 +274,7 @@ def get_fast_api_app(
       "/apps/{app_name}/users/{user_id}/sessions/{session_id}",
       response_model_exclude_none=True,
   )
-  def create_session(
+  def create_session_with_id(
       app_name: str,
       user_id: str,
       session_id: str,
@@ -254,7 +282,12 @@ def get_fast_api_app(
   ) -> Session:
     # Connect to managed session if agent_engine_id is set.
     app_name = agent_engine_id if agent_engine_id else app_name
-    if session_service.get_session(app_name, user_id, session_id) is not None:
+    if (
+        session_service.get_session(
+            app_name=app_name, user_id=user_id, session_id=session_id
+        )
+        is not None
+    ):
       logger.warning("Session already exists: %s", session_id)
       raise HTTPException(
           status_code=400, detail=f"Session already exists: {session_id}"
@@ -262,7 +295,7 @@ def get_fast_api_app(
 
     logger.info("New session created: %s", session_id)
     return session_service.create_session(
-        app_name, user_id, state, session_id=session_id
+        app_name=app_name, user_id=user_id, state=state, session_id=session_id
     )
 
   @app.post(
@@ -278,7 +311,9 @@ def get_fast_api_app(
     app_name = agent_engine_id if agent_engine_id else app_name
 
     logger.info("New session created")
-    return session_service.create_session(app_name, user_id, state)
+    return session_service.create_session(
+        app_name=app_name, user_id=user_id, state=state
+    )
 
   def _get_eval_set_file_path(app_name, agent_dir, eval_set_id) -> str:
     return os.path.join(
@@ -339,7 +374,7 @@ def get_fast_api_app(
       "/apps/{app_name}/eval_sets/{eval_set_id}/add_session",
       response_model_exclude_none=True,
   )
-  def add_session_to_eval_set(
+  async def add_session_to_eval_set(
       app_name: str, eval_set_id: str, req: AddSessionToEvalSetRequest
   ):
     pattern = r"^[a-zA-Z0-9_]+$"
@@ -350,7 +385,9 @@ def get_fast_api_app(
       )
 
     # Get the session
-    session = session_service.get_session(app_name, req.user_id, req.session_id)
+    session = session_service.get_session(
+        app_name=app_name, user_id=req.user_id, session_id=req.session_id
+    )
     assert session, "Session not found."
     # Load the eval set file data
     eval_set_file_path = _get_eval_set_file_path(
@@ -372,7 +409,9 @@ def get_fast_api_app(
     test_data = evals.convert_session_to_eval_format(session)
 
     # Populate the session with initial session state.
-    initial_session_state = create_empty_state(_get_root_agent(app_name))
+    initial_session_state = create_empty_state(
+        await _get_root_agent_async(app_name)
+    )
 
     eval_set_data.append({
         "name": req.eval_id,
@@ -409,7 +448,7 @@ def get_fast_api_app(
       "/apps/{app_name}/eval_sets/{eval_set_id}/run_eval",
       response_model_exclude_none=True,
   )
-  def run_eval(
+  async def run_eval(
       app_name: str, eval_set_id: str, req: RunEvalRequest
   ) -> list[RunEvalResult]:
     from .cli_eval import run_evals
@@ -426,7 +465,7 @@ def get_fast_api_app(
       logger.info(
           "Eval ids to run list is empty. We will all evals in the eval set."
       )
-    root_agent = _get_root_agent(app_name)
+    root_agent = await _get_root_agent_async(app_name)
     eval_results = list(
         run_evals(
             eval_set_to_evals,
@@ -456,7 +495,9 @@ def get_fast_api_app(
   def delete_session(app_name: str, user_id: str, session_id: str):
     # Connect to managed session if agent_engine_id is set.
     app_name = agent_engine_id if agent_engine_id else app_name
-    session_service.delete_session(app_name, user_id, session_id)
+    session_service.delete_session(
+        app_name=app_name, user_id=user_id, session_id=session_id
+    )
 
   @app.get(
       "/apps/{app_name}/users/{user_id}/sessions/{session_id}/artifacts/{artifact_name}",
@@ -469,8 +510,13 @@ def get_fast_api_app(
       artifact_name: str,
       version: Optional[int] = Query(None),
   ) -> Optional[types.Part]:
+    app_name = agent_engine_id if agent_engine_id else app_name
     artifact = artifact_service.load_artifact(
-        app_name, user_id, session_id, artifact_name, version
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        filename=artifact_name,
+        version=version,
     )
     if not artifact:
       raise HTTPException(status_code=404, detail="Artifact not found")
@@ -487,8 +533,13 @@ def get_fast_api_app(
       artifact_name: str,
       version_id: int,
   ) -> Optional[types.Part]:
+    app_name = agent_engine_id if agent_engine_id else app_name
     artifact = artifact_service.load_artifact(
-        app_name, user_id, session_id, artifact_name, version_id
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        filename=artifact_name,
+        version=version_id,
     )
     if not artifact:
       raise HTTPException(status_code=404, detail="Artifact not found")
@@ -501,7 +552,10 @@ def get_fast_api_app(
   def list_artifact_names(
       app_name: str, user_id: str, session_id: str
   ) -> list[str]:
-    return artifact_service.list_artifact_keys(app_name, user_id, session_id)
+    app_name = agent_engine_id if agent_engine_id else app_name
+    return artifact_service.list_artifact_keys(
+        app_name=app_name, user_id=user_id, session_id=session_id
+    )
 
   @app.get(
       "/apps/{app_name}/users/{user_id}/sessions/{session_id}/artifacts/{artifact_name}/versions",
@@ -510,8 +564,12 @@ def get_fast_api_app(
   def list_artifact_versions(
       app_name: str, user_id: str, session_id: str, artifact_name: str
   ) -> list[int]:
+    app_name = agent_engine_id if agent_engine_id else app_name
     return artifact_service.list_versions(
-        app_name, user_id, session_id, artifact_name
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        filename=artifact_name,
     )
 
   @app.delete(
@@ -520,18 +578,24 @@ def get_fast_api_app(
   def delete_artifact(
       app_name: str, user_id: str, session_id: str, artifact_name: str
   ):
+    app_name = agent_engine_id if agent_engine_id else app_name
     artifact_service.delete_artifact(
-        app_name, user_id, session_id, artifact_name
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        filename=artifact_name,
     )
 
   @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
-    session = session_service.get_session(app_id, req.user_id, req.session_id)
+    session = session_service.get_session(
+        app_name=app_id, user_id=req.user_id, session_id=req.session_id
+    )
     if not session:
       raise HTTPException(status_code=404, detail="Session not found")
-    runner = _get_runner(req.app_name)
+    runner = await _get_runner_async(req.app_name)
     events = [
         event
         async for event in runner.run_async(
@@ -548,7 +612,9 @@ def get_fast_api_app(
     # Connect to managed session if agent_engine_id is set.
     app_id = agent_engine_id if agent_engine_id else req.app_name
     # SSE endpoint
-    session = session_service.get_session(app_id, req.user_id, req.session_id)
+    session = session_service.get_session(
+        app_name=app_id, user_id=req.user_id, session_id=req.session_id
+    )
     if not session:
       raise HTTPException(status_code=404, detail="Session not found")
 
@@ -556,7 +622,7 @@ def get_fast_api_app(
     async def event_generator():
       try:
         stream_mode = StreamingMode.SSE if req.streaming else StreamingMode.NONE
-        runner = _get_runner(req.app_name)
+        runner = await _get_runner_async(req.app_name)
         async for event in runner.run_async(
             user_id=req.user_id,
             session_id=req.session_id,
@@ -582,47 +648,53 @@ def get_fast_api_app(
       "/apps/{app_name}/users/{user_id}/sessions/{session_id}/events/{event_id}/graph",
       response_model_exclude_none=True,
   )
-  def get_event_graph(
+  async def get_event_graph(
       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
-    session = session_service.get_session(app_id, user_id, session_id)
+    session = session_service.get_session(
+        app_name=app_id, 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)
-    if event:
-      from . import agent_graph
-
-      function_calls = event.get_function_calls()
-      function_responses = event.get_function_responses()
-      root_agent = _get_root_agent(app_name)
-      image_bytes = None
-      if function_calls:
-        function_call_highlights = []
-        for function_call in function_calls:
-          from_name = event.author
-          to_name = function_call.name
-          function_call_highlights.append((from_name, to_name))
-          image_bytes = agent_graph.get_agent_graph(
-              root_agent, function_call_highlights, True
-          )
-      elif function_responses:
-        function_responses_highlights = []
-        for function_response in function_responses:
-          from_name = function_response.name
-          to_name = event.author
-          function_responses_highlights.append((from_name, to_name))
-          image_bytes = agent_graph.get_agent_graph(
-              root_agent, function_responses_highlights, True
-          )
-      else:
+    if not event:
+      return {}
+
+    from . import agent_graph
+
+    function_calls = event.get_function_calls()
+    function_responses = event.get_function_responses()
+    root_agent = await _get_root_agent_async(app_name)
+    dot_graph = None
+    if function_calls:
+      function_call_highlights = []
+      for function_call in function_calls:
         from_name = event.author
-        to_name = ""
-        image_bytes = agent_graph.get_agent_graph(
-            root_agent, [(from_name, to_name)], True
+        to_name = function_call.name
+        function_call_highlights.append((from_name, to_name))
+        dot_graph = agent_graph.get_agent_graph(
+            root_agent, function_call_highlights
+        )
+    elif function_responses:
+      function_responses_highlights = []
+      for function_response in function_responses:
+        from_name = function_response.name
+        to_name = event.author
+        function_responses_highlights.append((from_name, to_name))
+        dot_graph = agent_graph.get_agent_graph(
+            root_agent, function_responses_highlights
         )
-      return Response(content=image_bytes, media_type="image/png")
-    return None
+    else:
+      from_name = event.author
+      to_name = ""
+      dot_graph = agent_graph.get_agent_graph(
+          root_agent, [(from_name, to_name)]
+      )
+    if dot_graph and isinstance(dot_graph, graphviz.Digraph):
+      return {"dot_src": dot_graph.source}
+    else:
+      return {}
 
   @app.websocket("/run_live")
   async def agent_live_run(
@@ -638,7 +710,9 @@ def get_fast_api_app(
 
     # Connect to managed session if agent_engine_id is set.
     app_id = agent_engine_id if agent_engine_id else app_name
-    session = session_service.get_session(app_id, user_id, session_id)
+    session = session_service.get_session(
+        app_name=app_id, user_id=user_id, session_id=session_id
+    )
     if not session:
       # Accept first so that the client is aware of connection establishment,
       # then close with a specific code.
@@ -648,7 +722,7 @@ def get_fast_api_app(
     live_request_queue = LiveRequestQueue()
 
     async def forward_events():
-      runner = _get_runner(app_name)
+      runner = await _get_runner_async(app_name)
       async for event in runner.run_live(
           session=session, live_request_queue=live_request_queue
       ):
@@ -682,30 +756,50 @@ def get_fast_api_app(
     except Exception as e:
       logger.exception("Error during live websocket communication: %s", e)
       traceback.print_exc()
+      WEBSOCKET_INTERNAL_ERROR_CODE = 1011
+      WEBSOCKET_MAX_BYTES_FOR_REASON = 123
+      await websocket.close(
+          code=WEBSOCKET_INTERNAL_ERROR_CODE,
+          reason=str(e)[:WEBSOCKET_MAX_BYTES_FOR_REASON],
+      )
     finally:
       for task in pending:
         task.cancel()
 
-  def _get_root_agent(app_name: str) -> Agent:
+  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]
-    envs.load_dotenv_for_agent(os.path.basename(app_name), agent_dir)
     agent_module = importlib.import_module(app_name)
-    root_agent: Agent = agent_module.agent.root_agent
+    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}.')
+
+    # Handle an awaitable root agent and await for the actual agent.
+    if inspect.isawaitable(root_agent):
+      try:
+        agent, exit_stack = await root_agent
+        exit_stacks.append(exit_stack)
+        root_agent = agent
+      except Exception as e:
+        raise RuntimeError(f"error getting root agent, {e}") from e
+
     root_agent_dict[app_name] = root_agent
     return root_agent
 
-  def _get_runner(app_name: str) -> Runner:
+  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)
     if app_name in runner_dict:
       return runner_dict[app_name]
-    root_agent = _get_root_agent(app_name)
+    root_agent = await _get_root_agent_async(app_name)
     runner = Runner(
         app_name=agent_engine_id if agent_engine_id else app_name,
         agent=root_agent,
         artifact_service=artifact_service,
         session_service=session_service,
+        memory_service=memory_service,
     )
     runner_dict[app_name] = runner
     return runner

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

@@ -12,11 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any
+from typing import Any, 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 +97,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

@@ -14,6 +14,7 @@
 
 import logging
 import os
+import sys
 import tempfile
 import time
 
@@ -22,11 +23,18 @@ 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)
+
+  # 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/__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',
 ]