Merge branch 'main' into fix/json-pointer-refs

Author: rohityan

src/google/adk/auth/auth_handler.py

@@ -36,6 +36,17 @@
   AUTHLIB_AVAILABLE = False
 
 
+def _normalize_oauth_scopes(
+    scopes: dict[str, str] | list[str] | None,
+) -> list[str]:
+  """Normalize OAuth scopes into the list shape expected by authlib."""
+  if not scopes:
+    return []
+  if isinstance(scopes, dict):
+    return list(scopes.keys())
+  return list(scopes)
+
+
 class AuthHandler:
   """A handler that handles the auth flow in Agent Development Kit to help
   orchestrate the credential request and response flow (e.g. OAuth flow)
@@ -164,7 +175,7 @@ def generate_auth_uri(
 
     if isinstance(auth_scheme, OpenIdConnectWithConfig):
       authorization_endpoint = auth_scheme.authorization_endpoint
-      scopes = auth_scheme.scopes
+      scopes = _normalize_oauth_scopes(auth_scheme.scopes)
     else:
       authorization_endpoint = (
           auth_scheme.flows.implicit
@@ -176,17 +187,20 @@ def generate_auth_uri(
           or auth_scheme.flows.password
           and auth_scheme.flows.password.tokenUrl
       )
-      scopes = (
-          auth_scheme.flows.implicit
-          and auth_scheme.flows.implicit.scopes
-          or auth_scheme.flows.authorizationCode
-          and auth_scheme.flows.authorizationCode.scopes
-          or auth_scheme.flows.clientCredentials
-          and auth_scheme.flows.clientCredentials.scopes
-          or auth_scheme.flows.password
-          and auth_scheme.flows.password.scopes
-      )
-      scopes = list(scopes.keys())
+      if auth_scheme.flows.implicit:
+        scopes = _normalize_oauth_scopes(auth_scheme.flows.implicit.scopes)
+      elif auth_scheme.flows.authorizationCode:
+        scopes = _normalize_oauth_scopes(
+            auth_scheme.flows.authorizationCode.scopes
+        )
+      elif auth_scheme.flows.clientCredentials:
+        scopes = _normalize_oauth_scopes(
+            auth_scheme.flows.clientCredentials.scopes
+        )
+      elif auth_scheme.flows.password:
+        scopes = _normalize_oauth_scopes(auth_scheme.flows.password.scopes)
+      else:
+        scopes = []
 
     client = OAuth2Session(
         auth_credential.oauth2.client_id,

src/google/adk/evaluation/final_response_match_v2.py

@@ -237,6 +237,14 @@ def aggregate_invocation_results(
         continue
       num_evaluated += 1
       num_valid += result.score
+
+    if num_evaluated == 0:
+      return EvaluationResult(
+          overall_score=None,
+          overall_eval_status=EvalStatus.NOT_EVALUATED,
+          per_invocation_results=per_invocation_results,
+      )
+
     overall_score = num_valid / num_evaluated
     return EvaluationResult(
         overall_score=overall_score,

src/google/adk/planners/plan_re_act_planner.py

@@ -71,7 +71,7 @@ def process_planning_response(
       # Split the response into reasoning and final answer parts.
       self._handle_non_function_call_parts(response_parts[i], preserved_parts)
 
-    if first_fc_part_index > 0:
+    if first_fc_part_index >= 0:
       j = first_fc_part_index + 1
       while j < len(response_parts):
         if response_parts[j].function_call:

src/google/adk/runners.py

@@ -106,10 +106,6 @@ def _find_active_task_isolation_scope(session) -> Optional[str]:
   return None
 
 
-def _is_tool_call_or_response(event: Event) -> bool:
-  return bool(event.get_function_calls() or event.get_function_responses())
-
-
 def _get_function_responses_from_content(
     content: types.Content,
 ) -> list[types.FunctionResponse]:
@@ -120,21 +116,6 @@ def _get_function_responses_from_content(
   ]
 
 
-def _is_transcription(event: Event) -> bool:
-  return (
-      event.input_transcription is not None
-      or event.output_transcription is not None
-  )
-
-
-def _has_non_empty_transcription_text(
-    transcription: types.Transcription,
-) -> bool:
-  return bool(
-      transcription and transcription.text and transcription.text.strip()
-  )
-
-
 def _apply_run_config_custom_metadata(
     event: Event, run_config: RunConfig | None
 ) -> None:
@@ -1393,22 +1374,6 @@ async def _exec_with_plugin(
       yield early_exit_event
     else:
       # Step 2: Otherwise continue with normal execution
-      # Note for live/bidi:
-      # the transcription may arrive later than the action(function call
-      # event and thus function response event). In this case, the order of
-      # transcription and function call event will be wrong if we just
-      # append as it arrives. To address this, we should check if there is
-      # transcription going on. If there is transcription going on, we
-      # should hold on appending the function call event until the
-      # transcription is finished. The transcription in progress can be
-      # identified by checking if the transcription event is partial. When
-      # the next transcription event is not partial, it means the previous
-      # transcription is finished. Then if there is any buffered function
-      # call event, we should append them after this finished(non-partial)
-      # transcription event.
-      buffered_events: list[Event] = []
-      is_transcribing: bool = False
-
       async with aclosing(execute_fn(invocation_context)) as agen:
         async for event in agen:
           _apply_run_config_custom_metadata(
@@ -1426,50 +1391,14 @@ async def _exec_with_plugin(
           )
 
           if is_live_call:
-            if event.partial and _is_transcription(event):
-              is_transcribing = True
-            if is_transcribing and _is_tool_call_or_response(event):
-              # only buffer function call and function response event which is
-              # non-partial
-              buffered_events.append(output_event)
-              continue
-            # Note for live/bidi: for audio response, it's considered as
-            # non-partial event(event.partial=None)
-            # event.partial=False and event.partial=None are considered as
-            # non-partial event; event.partial=True is considered as partial
-            # event.
-            if event.partial is not True:
-              if _is_transcription(event) and (
-                  _has_non_empty_transcription_text(event.input_transcription)
-                  or _has_non_empty_transcription_text(
-                      event.output_transcription
-                  )
-              ):
-                # transcription end signal, append buffered events
-                is_transcribing = False
-                logger.debug(
-                    'Appending transcription finished event: %s', event
-                )
-                if self._should_append_event(event, is_live_call):
-                  await self.session_service.append_event(
-                      session=invocation_context.session, event=output_event
-                  )
-
-                for buffered_event in buffered_events:
-                  logger.debug('Appending buffered event: %s', buffered_event)
-                  await self.session_service.append_event(
-                      session=invocation_context.session, event=buffered_event
-                  )
-                  yield buffered_event  # yield buffered events to caller
-                buffered_events = []
-              else:
-                # non-transcription event or empty transcription event, for
-                # example, event that stores blob reference, should be appended.
-                if self._should_append_event(event, is_live_call):
-                  logger.debug('Appending non-buffered event: %s', event)
-                  await self.session_service.append_event(
-                      session=invocation_context.session, event=output_event
-                  )
+            # Skip partial transcriptions for Live
+            if event.partial is not True and self._should_append_event(
+                event, is_live_call
+            ):
+              logger.debug('Appending live event: %s', output_event)
+              await self.session_service.append_event(
+                  session=invocation_context.session, event=output_event
+              )
           else:
             if event.partial is not True:
               await self.session_service.append_event(

src/google/adk/tools/_automatic_function_calling_util.py

@@ -37,6 +37,7 @@
 from ..features import FeatureName
 from ..features import is_feature_enabled
 from ..utils.variant_utils import GoogleLLMVariant
+from ._gemini_schema_util import _sanitize_schema_formats_for_gemini
 
 _py_type_2_schema_type = {
     'str': types.Type.STRING,
@@ -365,8 +366,13 @@ def from_function_with_options(
               param
           )
 
+          sanitized_schema = json_schema_dict
+          if variant == GoogleLLMVariant.GEMINI_API:
+            sanitized_schema = _sanitize_schema_formats_for_gemini(
+                json_schema_dict
+            )
           parameters_json_schema[name] = types.Schema.model_validate(
-              json_schema_dict
+              sanitized_schema
           )
           if param.default is not inspect.Parameter.empty:
             if param.default is not None:

src/google/adk/tools/_function_parameter_parse_util.py

@@ -123,10 +123,15 @@ def _generate_json_schema_for_parameter(
 ) -> dict[str, Any]:
   """Generates a JSON schema for a parameter using pydantic.TypeAdapter."""
 
-  param_schema_adapter = pydantic.TypeAdapter(
-      param.annotation,
-      config=pydantic.ConfigDict(arbitrary_types_allowed=True),
-  )
+  if inspect.isclass(param.annotation) and issubclass(
+      param.annotation, pydantic.BaseModel
+  ):
+    param_schema_adapter = pydantic.TypeAdapter(param.annotation)
+  else:
+    param_schema_adapter = pydantic.TypeAdapter(
+        param.annotation,
+        config=pydantic.ConfigDict(arbitrary_types_allowed=True),
+    )
   json_schema_dict = param_schema_adapter.json_schema()
   json_schema_dict = _add_unevaluated_items_to_fixed_len_tuple_schema(
       json_schema_dict

tests/unittests/auth/test_auth_handler.py

@@ -22,6 +22,7 @@
 from fastapi.openapi.models import APIKeyIn
 from fastapi.openapi.models import OAuth2
 from fastapi.openapi.models import OAuthFlowAuthorizationCode
+from fastapi.openapi.models import OAuthFlowClientCredentials
 from fastapi.openapi.models import OAuthFlows
 from google.adk.auth.auth_credential import AuthCredential
 from google.adk.auth.auth_credential import AuthCredentialTypes
@@ -273,6 +274,35 @@ def test_generate_auth_uri_openid(
     assert "client_id=mock_client_id" in result.oauth2.auth_uri
     assert result.oauth2.state == "mock_state"
 
+  @patch("google.adk.auth.auth_handler.OAuth2Session", MockOAuth2Session)
+  def test_generate_auth_uri_client_credentials_with_missing_scopes(
+      self, oauth2_credentials
+  ):
+    """Test client credentials flow tolerates missing scopes."""
+    auth_scheme = OAuth2(
+        flows=OAuthFlows(
+            clientCredentials=OAuthFlowClientCredentials(
+                tokenUrl="https://example.com/oauth2/token"
+            )
+        )
+    )
+    auth_scheme.flows.clientCredentials.scopes = None
+
+    config = AuthConfig(
+        auth_scheme=auth_scheme,
+        raw_auth_credential=oauth2_credentials,
+        exchanged_auth_credential=oauth2_credentials.model_copy(deep=True),
+    )
+
+    handler = AuthHandler(config)
+    result = handler.generate_auth_uri()
+
+    assert (
+        result.oauth2.auth_uri
+        == "https://example.com/oauth2/token?client_id=mock_client_id&scope="
+    )
+    assert result.oauth2.state == "mock_state"
+
   @patch("google.adk.auth.auth_handler.OAuth2Session")
   def test_generate_auth_uri_pkce(
       self, mock_oauth2_session, oauth2_auth_scheme, oauth2_credentials

tests/unittests/evaluation/test_final_response_match_v2.py

@@ -561,3 +561,34 @@ def test_aggregate_invocation_results():
   # Only 4 / 8 invocations are evaluated, and 2 / 4 are valid.
   assert aggregated_result.overall_score == 0.5
   assert aggregated_result.overall_eval_status == EvalStatus.PASSED
+
+
+def test_aggregate_invocation_results_none_evaluated():
+  evaluator = _create_test_evaluator_gemini(threshold=0.5)
+
+  actual_invocation, expected_invocation = _create_test_invocations(
+      "candidate text", "reference text"
+  )
+
+  per_invocation_results = [
+      PerInvocationResult(
+          actual_invocation=actual_invocation,
+          expected_invocation=expected_invocation,
+          score=None,
+          eval_status=EvalStatus.NOT_EVALUATED,
+      ),
+      PerInvocationResult(
+          actual_invocation=actual_invocation,
+          expected_invocation=expected_invocation,
+          score=1.0,
+          eval_status=EvalStatus.NOT_EVALUATED,
+      ),
+  ]
+
+  aggregated_result = evaluator.aggregate_invocation_results(
+      per_invocation_results
+  )
+
+  assert aggregated_result.overall_score is None
+  assert aggregated_result.overall_eval_status == EvalStatus.NOT_EVALUATED
+  assert aggregated_result.per_invocation_results == per_invocation_results

tests/unittests/planners/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2026 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.

tests/unittests/planners/test_plan_re_act_planner.py

@@ -0,0 +1,58 @@
+# Copyright 2026 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.
+
+"""Tests for PlanReActPlanner.process_planning_response."""
+
+from google.adk.planners.plan_re_act_planner import PlanReActPlanner
+from google.genai import types
+
+
+def _function_call_names(parts):
+  return [p.function_call.name for p in parts if p.function_call]
+
+
+def test_preserves_all_leading_parallel_function_calls():
+  """Parallel function calls at the start of the response must all survive.
+
+  Regression test: the trailing-group guard used ``> 0``, so when the first
+  part was a function call (index 0) the loop that collects the rest of the
+  parallel call group never ran and every call after the first was dropped.
+  """
+  planner = PlanReActPlanner()
+  response_parts = [
+      types.Part.from_function_call(name="get_weather", args={"city": "SF"}),
+      types.Part.from_function_call(name="get_time", args={"city": "SF"}),
+  ]
+
+  result = planner.process_planning_response(
+      callback_context=None, response_parts=response_parts
+  )
+
+  assert _function_call_names(result) == ["get_weather", "get_time"]
+
+
+def test_preserves_parallel_function_calls_after_leading_text():
+  """The same parallel group is preserved when text comes first."""
+  planner = PlanReActPlanner()
+  response_parts = [
+      types.Part(text="Let me look that up."),
+      types.Part.from_function_call(name="get_weather", args={"city": "SF"}),
+      types.Part.from_function_call(name="get_time", args={"city": "SF"}),
+  ]
+
+  result = planner.process_planning_response(
+      callback_context=None, response_parts=response_parts
+  )
+
+  assert _function_call_names(result) == ["get_weather", "get_time"]