Merge branch 'main' into cursor/bqaa-tool-error-result-241d

Author: Zsanz3

.github/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "2.9.2"
+  ".": "2.10.0"
 }

.github/release-please-config.json

@@ -57,5 +57,5 @@
       ]
     }
   },
-  "last-release-sha": "b65be0155cd68b849809b9a13dc1eda8e43474f6"
+  "last-release-sha": "84e3265c0b11dc4284a52ca335afedc2f286284e"
 }

CHANGELOG.md

@@ -33,7 +33,9 @@ questions in the same session, and the agent will maintain context.
 ## Tools Used
 
 - `list_accessible_data_agents`: Lists Data Agents you have permission to
-  access in the configured GCP project.
+  access in the configured GCP project. Automatically fetches all pages by
+  default, or supports manual pagination via optional `page_size` and
+  `page_token` parameters.
 - `get_data_agent_info`: Retrieves details about a specific Data Agent given
   its full resource name.
 - `ask_data_agent`: Chats with a specific Data Agent using natural language.

contributing/samples/integrations/data_agent/README.md

@@ -79,6 +79,52 @@ def finalize_model_response_event(
   return finalized_event
 
 
+def has_meaningful_content(llm_response: Optional[LlmResponse]) -> bool:
+  """Returns whether the LLM response contains meaningful, actionable content.
+
+  A response is considered to have meaningful content if it contains at least
+  one part with:
+  - An active function call or function response
+  - Executable code or a code execution result
+  - Inline data or file data
+  - Non-thought, non-whitespace text
+
+  Responses that are None, have no content, have empty parts, or contain only
+  thought parts (reasoning tokens) or whitespace-only text return False.
+
+  Args:
+    llm_response: The LLM response to check.
+
+  Returns:
+    True if the response contains meaningful content, False otherwise.
+  """
+  if (
+      not llm_response
+      or not llm_response.content
+      or not llm_response.content.parts
+  ):
+    return False
+
+  for part in llm_response.content.parts:
+    if part.function_call is not None:
+      return True
+    if part.function_response is not None:
+      return True
+    if part.executable_code is not None:
+      return True
+    if part.code_execution_result is not None:
+      return True
+    if part.inline_data is not None:
+      return True
+    if part.file_data is not None:
+      return True
+    is_thought = getattr(part, 'thought', False) or False
+    if not is_thought and part.text and part.text.strip():
+      return True
+
+  return False
+
+
 async def handle_before_model_callback(
     invocation_context: InvocationContext,
     llm_request: LlmRequest,

src/google/adk/flows/llm_flows/core/_finalizer.py

@@ -27,13 +27,16 @@
 from ....agents.invocation_context import InvocationContext
 from ....agents.readonly_context import ReadonlyContext
 from ....events.event import Event
+from ....features import FeatureName
+from ....features import is_feature_enabled
 from ....live.live_request_queue import LiveRequestQueue
 from ....models.llm_request import LlmRequest
 from ....models.llm_response import LlmResponse
 from ....telemetry.tracing import trace_call_llm
 from ....telemetry.tracing import tracer
 from ....utils._runner_utils import _with_caller_context
 from ....utils.context_utils import Aclosing
+from ._finalizer import has_meaningful_content
 from ._utils import as_llm_agent as _as_llm_agent
 from ._utils import require_run_config as _require_run_config
 
@@ -47,19 +50,27 @@
 NO_CONTENT_ERROR_MESSAGE = (
     'The model returned no content (finish_reason=STOP with empty parts).'
 )
+NO_MEANINGFUL_CONTENT_ERROR_MESSAGE = (
+    'The model returned no actionable content (finish_reason=STOP with'
+    ' thought-only or whitespace-only parts).'
+)
 
 
 def apply_empty_response_policy(
     invocation_context: InvocationContext,
     llm_response: LlmResponse,
 ) -> None:
-  """Marks non-streaming empty STOP responses with NO_CONTENT_ERROR_CODE.
-
-  A non-streaming turn that finishes with STOP but has no content parts would
-  otherwise be skipped and become a silent empty final response; surface it as
-  an actionable error instead. Streaming is excluded because a terminal
-  finish-only chunk legitimately follows content already streamed in earlier
-  chunks.
+  """Marks terminal STOP responses that lack meaningful content as errors.
+
+  A turn that finishes with STOP but has no meaningful content (empty parts,
+  thought-only parts, or whitespace-only text) would otherwise be skipped or
+  treated as a complete answer; surface it as an actionable error instead.
+  In SSE streaming, progressive SSE aggregates the entire turn into a single
+  non-partial response, so a non-partial response carrying only thought or
+  whitespace parts represents a completed turn with no answer, whereas empty
+  parts (a terminal finish-only chunk) and non-progressive SSE (where the
+  aggregator emits a non-partial thought-only chunk before a function call)
+  are excluded.
 
   This must run before the response processors. Emptiness is a property of
   what the model returned, so it can only be judged before local processing
@@ -68,17 +79,27 @@ def apply_empty_response_policy(
   once it has run the code and emitted its result.
   """
   run_config = _require_run_config(invocation_context)
+  has_parts = bool(llm_response.content and llm_response.content.parts)
   if (
       not llm_response.partial
       and llm_response.error_code is None
       and llm_response.finish_reason == types.FinishReason.STOP
-      and (not llm_response.content or not llm_response.content.parts)
-      and run_config.streaming_mode != StreamingMode.SSE
+      and not has_meaningful_content(llm_response)
+      and (
+          run_config.streaming_mode != StreamingMode.SSE
+          or (
+              has_parts
+              and is_feature_enabled(FeatureName.PROGRESSIVE_SSE_STREAMING)
+          )
+      )
   ):
     llm_response.error_code = NO_CONTENT_ERROR_CODE
-    llm_response.error_message = (
-        llm_response.error_message or NO_CONTENT_ERROR_MESSAGE
+    default_message = (
+        NO_MEANINGFUL_CONTENT_ERROR_MESSAGE
+        if has_parts
+        else NO_CONTENT_ERROR_MESSAGE
     )
+    llm_response.error_message = llm_response.error_message or default_message
 
 
 async def resolve_llm(invocation_context: InvocationContext) -> BaseLlm:

src/google/adk/flows/llm_flows/core/_model_call.py

@@ -3573,6 +3573,7 @@ async def generate_content_async(
       usage_metadata = None
       grounding_metadata = None
       last_finish_reason: str | None = None
+      last_model_version: str | None = None
       fallback_index = 0
       multiple_choices_logged = False
 
@@ -3688,6 +3689,8 @@ def _reset_stream_buffers() -> None:
         last_finish_reason = None
 
       async for part in await self.llm_client.acompletion(**completion_args):
+        if getattr(part, "model", None):
+          last_model_version = part.model
         part_choices = part.get("choices") or []
         if not multiple_choices_logged and (
             len(part_choices) > 1
@@ -3828,36 +3831,33 @@ def _reset_stream_buffers() -> None:
       # the provider actually sent rather than assuming a clean stop, so a
       # filtered stream reports the same finish_reason and error_code that the
       # non-streaming path reports.
+      resolved_model_version = last_model_version or effective_model
       if function_calls and not aggregated_llm_response_with_tool_call:
         aggregated_llm_response_with_tool_call = _finalize_tool_call_response(
-            model_version=part.model,
+            model_version=resolved_model_version,
             finish_reason=last_finish_reason or "tool_calls",
         )
         _reset_stream_buffers()
 
       if (text_parts or reasoning_parts) and not aggregated_llm_response:
         aggregated_llm_response = _finalize_text_response(
-            model_version=part.model,
+            model_version=resolved_model_version,
             finish_reason=last_finish_reason or "stop",
         )
         _reset_stream_buffers()
       elif (
           not aggregated_llm_response
           and not aggregated_llm_response_with_tool_call
       ):
-        # The stream ended abnormally without ever producing content (an
-        # immediate content filter, or truncation before the first token).
-        # Non-streaming reports that as an error response; without this the
-        # generator ends having yielded nothing at all, so the reason, the
-        # error and the usage are all dropped and the caller sees a silent stop.
-        trailing_finish_reason = last_finish_reason or ""
-        if trailing_finish_reason and _map_finish_reason(
-            trailing_finish_reason
-        ) not in (None, types.FinishReason.STOP):
-          aggregated_llm_response = _finalize_text_response(
-              model_version=part.model,
-              finish_reason=trailing_finish_reason,
-          )
+        # The stream ended without ever producing content or tool calls (an
+        # immediate content filter, truncation before the first token, or a
+        # normal stop/tool_calls/function_call/EOF with empty deltas). Finalize
+        # an empty response so the finish_reason, error, and usage are
+        # preserved rather than ending the generator having yielded nothing.
+        aggregated_llm_response = _finalize_text_response(
+            model_version=resolved_model_version,
+            finish_reason=last_finish_reason or "stop",
+        )
 
       # waiting until streaming ends to yield the llm_response as litellm tends
       # to send chunk that contains usage_metadata after the chunk with

src/google/adk/models/lite_llm.py

@@ -2063,15 +2063,37 @@ async def _handle_new_message(
           state_delta=state_delta,
       )
 
-  def _collect_toolset(self, agent: BaseAgent) -> set[BaseToolset]:
+  def _collect_toolset(
+      self, root: BaseNode, visited: set[int] | None = None
+  ) -> set[BaseToolset]:
+    if visited is None:
+      visited = set()
+    root_id = id(root)
+    if root_id in visited:
+      return set()
+    visited.add(root_id)
+
     toolsets: set[BaseToolset] = set()
-    if hasattr(agent, 'tools'):
-      for tool_union in agent.tools:
+    if hasattr(root, 'tools'):
+      for tool_union in getattr(root, 'tools', ()) or ():
         if isinstance(tool_union, BaseToolset):
           toolsets.add(tool_union)
-    if hasattr(agent, 'sub_agents'):
-      for sub_agent in agent.sub_agents:
-        toolsets.update(self._collect_toolset(sub_agent))
+    if hasattr(root, 'sub_agents'):
+      for sub_agent in getattr(root, 'sub_agents', ()) or ():
+        toolsets.update(self._collect_toolset(sub_agent, visited))
+    if hasattr(root, 'graph') and getattr(root, 'graph', None):
+      graph = getattr(root, 'graph')
+      nodes = getattr(graph, 'nodes', None)
+      if nodes:
+        node_iter = nodes.values() if isinstance(nodes, dict) else nodes
+        for node in node_iter:
+          toolsets.update(self._collect_toolset(node, visited))
+    if hasattr(root, '_node') and getattr(root, '_node', None):
+      toolsets.update(self._collect_toolset(getattr(root, '_node'), visited))
+    if hasattr(root, '_inner_node') and getattr(root, '_inner_node', None):
+      toolsets.update(
+          self._collect_toolset(getattr(root, '_inner_node'), visited)
+      )
     return toolsets
 
   async def _cleanup_toolsets(
@@ -2139,7 +2161,7 @@ async def close(self) -> None:
     """Closes the runner."""
     logger.info('Closing runner...')
     # Close Toolsets
-    if isinstance(self.agent, BaseAgent):
+    if self.agent is not None:
       await self._cleanup_toolsets(self._collect_toolset(self.agent))
 
     # Close Plugins