Merge branch 'main' into fix/memory-non-latin-search

Author: yodeee9

contributing/samples/hello_world/agent.py

@@ -65,7 +65,7 @@ async def check_prime(nums: list[int]) -> str:
 
 
 root_agent = Agent(
-    model='gemini-2.5-flash',
+    model='projects/adk-cat/locations/us-central1/publishers/google/models/gemini-2.5-flash',
     name='hello_world_agent',
     description=(
         'hello world agent that can roll a dice of 8 sides and check prime'

src/google/adk/cli/utils/gcp_utils.py

@@ -139,7 +139,11 @@ def sign_up_express(
       "POST",
       ":signUp",
       location=location,
-      data={"region": location, "tos_accepted": True},
+      data={
+          "region": location,
+          "tos_accepted": True,
+          "get_default_api_key": True,
+      },
   )
   return {
       "project_id": project.get("projectId"),

src/google/adk/evaluation/simulation/llm_backed_user_simulator.py

@@ -16,7 +16,6 @@
 
 import logging
 from typing import ClassVar
-from typing import Optional
 
 from google.genai import types as genai_types
 from pydantic import Field
@@ -72,7 +71,7 @@ class LlmBackedUserSimulatorConfig(BaseUserSimulatorConfig):
 (Not recommended) If you don't want a limit, you can set the value to -1.""",
   )
 
-  custom_instructions: Optional[str] = Field(
+  custom_instructions: str | None = Field(
       default=None,
       description="""Custom instructions for the LlmBackedUserSimulator. The
 instructions must contain the following formatting placeholders following Jinja syntax:
@@ -88,7 +87,7 @@ class LlmBackedUserSimulatorConfig(BaseUserSimulatorConfig):
 
   @field_validator("custom_instructions")
   @classmethod
-  def validate_custom_instructions(cls, value: Optional[str]) -> Optional[str]:
+  def validate_custom_instructions(cls, value: str | None) -> str | None:
     if value is None:
       return value
     if not is_valid_user_simulator_template(
@@ -158,11 +157,11 @@ def _summarize_conversation(
   async def _get_llm_response(
       self,
       rewritten_dialogue: str,
-  ) -> str:
-    """Sends a user message generation request to the LLM and returns the full response."""
+  ) -> tuple[str, str | None]:
+    """Sends a user message generation request to the LLM and returns the full response and potential error reason."""
     if self._invocation_count == 0:
       # first invocation - send the static starting prompt
-      return self._conversation_scenario.starting_prompt
+      return self._conversation_scenario.starting_prompt, None
 
     user_agent_instructions = get_llm_backed_user_simulator_prompt(
         conversation_plan=self._conversation_scenario.conversation_plan,
@@ -187,19 +186,44 @@ async def _get_llm_response(
     add_default_retry_options_if_not_present(llm_request)
 
     response = ""
+    error_reason = None
+    has_thought_tokens = False
     async with Aclosing(self._llm.generate_content_async(llm_request)) as agen:
       async for llm_response in agen:
+        error_code = llm_response.error_code
+        if error_code:
+          logger.warning(
+              "User simulator LLM returned error: code=%s, message=%s",
+              error_code,
+              getattr(llm_response, "error_message", ""),
+          )
+          error_reason = f"safety filters or other error (code={error_code})"
+          response = ""
+          break
+
         generated_content: genai_types.Content = llm_response.content
         if (
             not generated_content
             or not hasattr(generated_content, "parts")
             or not generated_content.parts
         ):
           continue
+
         for part in generated_content.parts:
-          if part.text and not part.thought:
+          if part.thought:
+            has_thought_tokens = True
+          elif part.text:
             response += part.text
-    return response
+
+    if not response:
+      if error_reason:
+        pass  # Keep the error reason from error_code
+      elif has_thought_tokens:
+        error_reason = "LLM returned only thinking tokens"
+      else:
+        error_reason = "LLM returned empty response"
+
+    return response, error_reason
 
   @override
   async def get_next_user_message(
@@ -234,11 +258,11 @@ async def get_next_user_message(
     rewritten_dialogue = self._summarize_conversation(events)
 
     # query the LLM for the next user message
-    response = await self._get_llm_response(rewritten_dialogue)
+    response, error_reason = await self._get_llm_response(rewritten_dialogue)
     self._invocation_count += 1
 
     # is the conversation over? (Has the user simulator output the stop signal?)
-    if _STOP_SIGNAL.lower() in response.lower():
+    if response and _STOP_SIGNAL.lower() in response.lower():
       logger.info(
           "Stopping user message generation as the stop signal was detected."
       )
@@ -256,11 +280,11 @@ async def get_next_user_message(
 
     # if we are here, the user agent failed to generate a message, which is not
     # a valid result for the LLM backed user simulator.
-    raise RuntimeError("Failed to generate a user message")
+    raise RuntimeError(f"Failed to generate a user message: {error_reason}")
 
   @override
   def get_simulation_evaluator(
       self,
-  ) -> Optional[Evaluator]:
+  ) -> Evaluator | None:
     """Returns an Evaluator that evaluates if the simulation was successful or not."""
     raise NotImplementedError()

src/google/adk/flows/llm_flows/contents.py

@@ -795,8 +795,8 @@ def _is_request_input_event(event: Event) -> bool:
   return _is_function_call_event(event, REQUEST_INPUT_FUNCTION_CALL_NAME)
 
 
-def _is_live_model_audio_event_with_inline_data(event: Event) -> bool:
-  """Check if the event is a live/bidi audio event with inline data.
+def _is_live_model_media_event_with_inline_data(event: Event) -> bool:
+  """Check if the event is a live/bidi media event (audio, video, image) with inline data.
 
   There are two possible cases and we only care about the second case:
   content=Content(
@@ -826,12 +826,14 @@ def _is_live_model_audio_event_with_inline_data(event: Event) -> bool:
   if not event.content or not event.content.parts:
     return False
   for part in event.content.parts:
-    if (
-        part.inline_data
-        and part.inline_data.mime_type
-        and part.inline_data.mime_type.startswith('audio/')
-    ):
-      return True
+    if part.inline_data and part.inline_data.mime_type:
+      mime = part.inline_data.mime_type.lower()
+      if (
+          mime.startswith('audio/')
+          or mime.startswith('video/')
+          or mime.startswith('image/')
+      ):
+        return True
   return False
 
 

src/google/adk/runners.py

@@ -786,17 +786,17 @@ async def _compute_artifact_delta_for_rewind(
 
   def _should_append_event(self, event: Event, is_live_call: bool) -> bool:
     """Checks if an event should be appended to the session."""
-    # Don't append audio response from model in live mode to session.
+    # Don't append media (audio/video/image) response from model in live mode to session.
     # The data is appended to artifacts with a reference in file_data in the
-    # event.
+    # event if save_live_blob is True.
     # We should append non-partial events only.For example, non-finished(partial)
     # transcription events should not be appended.
     # Function call and function response events should be appended.
     # Other control events should be appended.
-    if is_live_call and contents._is_live_model_audio_event_with_inline_data(
+    if is_live_call and contents._is_live_model_media_event_with_inline_data(
         event
     ):
-      # We don't append live model audio events with inline data to avoid
+      # We don't append live model media events with inline data to avoid
       # storing large blobs in the session. However, events with file_data
       # (references to artifacts) should be appended.
       return False
@@ -1616,6 +1616,10 @@ async def close(self):
     if self.plugin_manager:
       await self.plugin_manager.close()
 
+    # Close Session Service
+    if self.session_service:
+      await self.session_service.flush()
+
     logger.info('Runner closed.')
 
   if sys.version_info < (3, 11):

src/google/adk/sessions/base_session_service.py

@@ -124,6 +124,13 @@ async def append_event(self, session: Session, event: Event) -> Event:
     session.events.append(event)
     return event
 
+  async def flush(self):
+    """Flushes any buffered events.
+
+    For non-buffering implementations, this can be a no-op.
+    """
+    pass
+
   def _apply_temp_state(self, session: Session, event: Event) -> None:
     """Applies temp-scoped state delta to the in-memory session state.
 

src/google/adk/tools/environment/_environment_toolset.py

@@ -60,17 +60,21 @@ def __init__(
       self,
       *,
       environment: BaseEnvironment,
+      max_output_chars: Optional[int] = None,
       **kwargs: Any,
   ):
     """Create an environment toolset.
 
     Args:
-      environment: The environment used to execute commands and
-        perform file I/O.
+      environment: The environment used to execute commands and perform file
+        I/O.
+      max_output_chars: Maximum character limit for stdout/stderr/file
+        truncation.
       **kwargs: Forwarded to ``BaseToolset.__init__``.
     """
     super().__init__(**kwargs)
     self._environment = environment
+    self._max_output_chars = max_output_chars
     self._environment_initialized = False
 
   @override
@@ -82,8 +86,10 @@ async def get_tools(
       await self._environment.initialize()
       self._environment_initialized = True
     return [
-        ExecuteTool(self._environment),
-        ReadFileTool(self._environment),
+        ExecuteTool(self._environment, max_output_chars=self._max_output_chars),
+        ReadFileTool(
+            self._environment, max_output_chars=self._max_output_chars
+        ),
         EditFileTool(self._environment),
         WriteFileTool(self._environment),
     ]

src/google/adk/tools/environment/_tools.py

@@ -58,12 +58,20 @@ def _truncate(text: str, limit: int = MAX_OUTPUT_CHARS) -> str:
 class ExecuteTool(BaseTool):
   """Run a shell command in the environment's working directory."""
 
-  def __init__(self, environment: BaseEnvironment):
+  def __init__(
+      self,
+      environment: BaseEnvironment,
+      *,
+      max_output_chars: Optional[int] = None,
+  ):
     super().__init__(
         name='Execute',
         description=_EXECUTE_TOOL_DESCRIPTION,
     )
     self._environment = environment
+    self._max_output_chars = (
+        max_output_chars if max_output_chars is not None else MAX_OUTPUT_CHARS
+    )
 
   @override
   def _get_declaration(self) -> Optional[types.FunctionDeclaration]:
@@ -111,9 +119,15 @@ async def run_async(
 
     result: dict[str, Any] = {'status': 'ok'}
     if execution_result.stdout:
-      result['stdout'] = _truncate(execution_result.stdout)
+      result['stdout'] = _truncate(
+          execution_result.stdout,
+          limit=self._max_output_chars,
+      )
     if execution_result.stderr:
-      result['stderr'] = _truncate(execution_result.stderr)
+      result['stderr'] = _truncate(
+          execution_result.stderr,
+          limit=self._max_output_chars,
+      )
     if execution_result.exit_code != 0:
       result['status'] = 'error'
       result['exit_code'] = execution_result.exit_code
@@ -127,7 +141,12 @@ async def run_async(
 class ReadFileTool(BaseTool):
   """Read a file from the environment."""
 
-  def __init__(self, environment: BaseEnvironment):
+  def __init__(
+      self,
+      environment: BaseEnvironment,
+      *,
+      max_output_chars: Optional[int] = None,
+  ):
     super().__init__(
         name='ReadFile',
         description=(
@@ -136,6 +155,9 @@ def __init__(self, environment: BaseEnvironment):
         ),
     )
     self._environment = environment
+    self._max_output_chars = (
+        max_output_chars if max_output_chars is not None else MAX_OUTPUT_CHARS
+    )
 
   @override
   def _get_declaration(self) -> Optional[types.FunctionDeclaration]:
@@ -190,7 +212,13 @@ async def run_async(
       cmd = f"cat -n '{path}' | sed -n '{sed_range}p'"
       res = await self._environment.execute(cmd)
       if res.exit_code == 0:
-        return {'status': 'ok', 'content': _truncate(res.stdout)}
+        return {
+            'status': 'ok',
+            'content': _truncate(
+                res.stdout,
+                limit=self._max_output_chars,
+            ),
+        }
 
     try:
       data_bytes = await self._environment.read_file(path)
@@ -217,7 +245,13 @@ async def run_async(
       numbered = ''.join(
           f'{start + i:6d}\t{line}' for i, line in enumerate(selected)
       )
-      result = {'status': 'ok', 'content': _truncate(numbered)}
+      result = {
+          'status': 'ok',
+          'content': _truncate(
+              numbered,
+              limit=self._max_output_chars,
+          ),
+      }
       if start > 1 or end < total:
         result['total_lines'] = total
       return result

tests/unittests/cli/utils/test_gcp_utils.py

@@ -126,11 +126,19 @@ def test_sign_up_express(self, mock_auth_default, mock_session_cls):
     result = gcp_utils.sign_up_express()
     self.assertEqual(result["project_id"], "new-project")
     self.assertEqual(result["api_key"], "new-api-key")
-    args, _ = mock_session.post.call_args
+    args, kwargs = mock_session.post.call_args
     self.assertEqual(
         args[0],
         "https://us-central1-aiplatform.googleapis.com/v1beta1/vertexExpress:signUp",
     )
+    self.assertEqual(
+        kwargs["json"],
+        {
+            "region": "us-central1",
+            "tos_accepted": True,
+            "get_default_api_key": True,
+        },
+    )
 
   @mock.patch(
       "google.adk.cli.utils.gcp_utils.resourcemanager_v3.ProjectsClient"