Merge branch 'main' into fix/safe-json-serialize-exception-handling

Author: voidborne-d

pyproject.toml

@@ -124,7 +124,7 @@ optional-dependencies.extensions = [
   "k8s-agent-sandbox>=0.1.1.post3",                                  # For GkeCodeExecutor sandbox mode
   "kubernetes>=29",                                                  # For GkeCodeExecutor
   "langgraph>=0.2.60,<0.4.8",                                        # For LangGraphAgent
-  "litellm>=1.75.5,<=1.82.6",                                        # For LiteLlm class. Upper bound pinned: versions 1.82.7+ compromised in supply chain attack.
+  "litellm>=1.83.7,<=1.83.14",                                       # For LiteLlm class. Lower bound: 5 CVE patches (2026-04). Upper bound pinned to current latest; bump deliberately. See #5488.
   "llama-index-embeddings-google-genai>=0.3",                        # For files retrieval using LlamaIndex.
   "llama-index-readers-file>=0.4",                                   # For retrieval using LlamaIndex.
   "lxml>=5.3",                                                       # For load_web_page tool.
@@ -143,7 +143,7 @@ optional-dependencies.test = [
   "kubernetes>=29",                                                  # For GkeCodeExecutor
   "langchain-community>=0.3.17",
   "langgraph>=0.2.60,<0.4.8",                                        # For LangGraphAgent
-  "litellm>=1.75.5,<=1.82.6",                                        # For LiteLLM tests. Upper bound pinned: versions 1.82.7+ compromised in supply chain attack.
+  "litellm>=1.83.7,<=1.83.14",                                       # For LiteLLM tests. Lower bound: 5 CVE patches (2026-04). Upper bound pinned to current latest; bump deliberately. See #5488.
   "llama-index-readers-file>=0.4",                                   # For retrieval tests
   "openai>=1.100.2",                                                 # For LiteLLM
   "opentelemetry-instrumentation-google-genai>=0.3b0,<1",

src/google/adk/agents/remote_a2a_agent.py

@@ -422,6 +422,11 @@ def _construct_message_parts_from_session(
         if not isinstance(converted_parts, list):
           converted_parts = [converted_parts] if converted_parts else []
 
+        if event.author == "user":
+          for part in converted_parts:
+            part.root.metadata = part.root.metadata or {}
+            part.root.metadata["is_user_input"] = True
+
         if converted_parts:
           message_parts.extend(converted_parts)
         else:

src/google/adk/integrations/agent_identity/gcp_auth_provider.py

@@ -82,7 +82,7 @@ def _construct_auth_credential(
     return AuthCredential(
         auth_type=AuthCredentialTypes.HTTP,
         http=HttpAuth(
-            scheme="bearer",
+            scheme="Bearer",
             credentials=HttpCredentials(token=response.token),
         ),
     )

src/google/adk/optimization/local_eval_sampler.py

@@ -289,11 +289,7 @@ def _extract_eval_data(
         for eval_metric_result in per_invocation_result.eval_metric_results:
           eval_metric_results.append({
               "metric_name": eval_metric_result.metric_name,
-              "score": (
-                  round(eval_metric_result.score, 2)
-                  if eval_metric_result.score is not None
-                  else None
-              ),  # accurate enough
+              "score": round(eval_metric_result.score, 2),  # accurate enough
               "eval_status": eval_metric_result.eval_status.name,
           })
         per_invocation_result_dict = {

src/google/adk/plugins/reflect_retry_tool_plugin.py

@@ -242,8 +242,8 @@ async def _handle_tool_error(
     """
     if self.max_retries == 0:
       if self.throw_exception_if_retry_exceeded:
-        raise error
-      return self._get_tool_retry_exceed_msg(tool, error, tool_args)
+        raise self._ensure_exception(error)
+      return self._get_tool_retry_exceed_msg(tool, tool_args, error)
 
     scope_key = self._get_scope_key(tool_context)
     async with self._lock:
@@ -260,7 +260,7 @@ async def _handle_tool_error(
 
       # Max Retry exceeded
       if self.throw_exception_if_retry_exceeded:
-        raise error
+        raise self._ensure_exception(error)
       else:
         return self._get_tool_retry_exceed_msg(tool, tool_args, error)
 

src/google/adk/skills/skill_registry.py

@@ -0,0 +1,83 @@
+# 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.
+
+"""Interface for skill registry."""
+
+from __future__ import annotations
+
+import abc
+from typing import Any
+from typing import Dict
+from typing import List
+
+from . import models
+
+
+class SkillRegistry(abc.ABC):
+  """Interface for a skill registry."""
+
+  @abc.abstractmethod
+  async def get_skill(
+      self, *, name: str, version: str | None = None
+  ) -> models.Skill:
+    """Fetches a skill from the registry.
+
+    Args:
+        name: The name of the skill.
+        version: Optional version of the skill.
+
+    Returns:
+        A Skill object.
+    """
+    pass
+
+  @abc.abstractmethod
+  async def search_skills(
+      self,
+      *,
+      query: str,
+      filters: Dict[str, Any] | None = None,
+      **kwargs,
+  ) -> List[models.Frontmatter]:
+    """Searches for skills in the registry.
+
+    Args:
+        query: The search query.
+        filters: Optional filters.
+        **kwargs: Additional implementation-specific arguments.
+
+    Returns:
+        A list of Frontmatter objects for discovery.
+    """
+    pass
+
+  @abc.abstractmethod
+  def get_filter_schema(self) -> Dict[str, Any] | None:
+    """Returns the JSON schema for the filters supported by this registry.
+
+    Returns:
+        A JSON schema dict or None if filters are not supported
+    """
+    pass
+
+  def get_search_description(self) -> str:
+    """Returns the description for the search_skills tool.
+
+    Registries can override this to provide specialized instructions to the
+    model on how to use their specific search capabilities.
+    """
+    return (
+        "Searches for relevant skills in the registry based on a semantic or"
+        " keyword query."
+    )

src/google/adk/telemetry/_experimental_semconv.py

@@ -51,7 +51,7 @@
 try:
   from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import GEN_AI_TOOL_DEFINITIONS
 except ImportError:
-  GEN_AI_TOOL_DEFINITIONS = 'gen_ai.tool_definitions'
+  GEN_AI_TOOL_DEFINITIONS = 'gen_ai.tool.definitions'
 
 OTEL_SEMCONV_STABILITY_OPT_IN = 'OTEL_SEMCONV_STABILITY_OPT_IN'
 

src/google/adk/tools/skill_toolset.py

@@ -37,6 +37,7 @@
 from ..features import FeatureName
 from ..skills import models
 from ..skills import prompt
+from ..skills.skill_registry import SkillRegistry
 from .base_tool import BaseTool
 from .base_toolset import BaseToolset
 from .function_tool import FunctionTool
@@ -155,6 +156,20 @@ async def run_async(
       }
 
     skill = self._toolset._get_skill(skill_name)
+    if not skill and self._toolset._registry:
+      try:
+        skill = await self._toolset._registry.get_skill(name=skill_name)
+        if skill:
+          self._toolset._skills[skill_name] = skill
+      except Exception as e:
+        logger.exception(
+            "Failed to fetch skill '%s' from registry.", skill_name
+        )
+        return {
+            "error": f"Failed to fetch skill '{skill_name}' from registry: {e}",
+            "error_code": "REGISTRY_ERROR",
+        }
+
     if not skill:
       return {
           "error": f"Skill '{skill_name}' not found.",
@@ -771,14 +786,75 @@ async def run_async(
     )
 
 
+@experimental(FeatureName.SKILL_TOOLSET)
+class SearchSkillsTool(BaseTool):
+  """Tool to search for relevant skills in the registry."""
+
+  def __init__(self, toolset: "SkillToolset"):
+    super().__init__(
+        name="search_skills",
+        description=toolset._registry.get_search_description(),
+    )
+    self._toolset = toolset
+
+  def _get_declaration(self) -> types.FunctionDeclaration | None:
+    properties = {
+        "query": {
+            "type": "string",
+            "description": "Semantic or keyword search query.",
+        },
+    }
+    filter_schema = self._toolset._registry.get_filter_schema()
+    if filter_schema:
+      properties["filters"] = filter_schema
+    return types.FunctionDeclaration(
+        name=self.name,
+        description=self.description,
+        parameters_json_schema={
+            "type": "object",
+            "properties": properties,
+            "required": ["query"],
+        },
+    )
+
+  async def run_async(
+      self, *, args: dict[str, Any], tool_context: ToolContext
+  ) -> Any:
+    query = args.get("query")
+    filters = args.get("filters")
+
+    if not query:
+      return {
+          "error": "Argument 'query' is required.",
+          "error_code": "INVALID_ARGUMENTS",
+      }
+
+    results = await self._toolset._registry.search_skills(
+        query=query, filters=filters
+    )
+
+    formatted_results = []
+    for r in results:
+      if r.name in self._toolset._skills:
+        logger.warning(
+            "Naming conflict detected: Skill '%s' exists both locally and in"
+            " the registry. Filtering out the registry skill.",
+            r.name,
+        )
+        continue
+      formatted_results.append(r.model_dump())
+    return formatted_results
+
+
 @experimental(FeatureName.SKILL_TOOLSET)
 class SkillToolset(BaseToolset):
   """A toolset for managing and interacting with agent skills."""
 
   def __init__(
       self,
-      skills: list[models.Skill],
+      skills: list[models.Skill] | None = None,
       *,
+      registry: Optional[SkillRegistry] = None,
       code_executor: Optional[BaseCodeExecutor] = None,
       script_timeout: int = _DEFAULT_SCRIPT_TIMEOUT,
       additional_tools: list[ToolUnion] | None = None,
@@ -787,6 +863,7 @@ def __init__(
 
     Args:
       skills: List of skills to register.
+      registry: Optional skill registry for dynamic discovery.
       code_executor: Optional code executor for script execution.
       script_timeout: Timeout in seconds for shell script execution via
         subprocess.run. Defaults to 300 seconds. Does not apply to Python
@@ -796,12 +873,13 @@ def __init__(
 
     # Check for duplicate skill names
     seen: set[str] = set()
-    for skill in skills:
+    for skill in skills or []:
       if skill.name in seen:
         raise ValueError(f"Duplicate skill name '{skill.name}'.")
       seen.add(skill.name)
 
-    self._skills = {skill.name: skill for skill in skills}
+    self._skills = {skill.name: skill for skill in skills or []}
+    self._registry = registry
     self._code_executor = code_executor
     self._script_timeout = script_timeout
     self._use_invocation_cache = False
@@ -824,6 +902,8 @@ def __init__(
         LoadSkillResourceTool(self),
         RunSkillScriptTool(self),
     ]
+    if self._registry:
+      self._tools.append(SearchSkillsTool(self))
 
   async def get_tools(
       self, readonly_context: ReadonlyContext | None = None
@@ -904,6 +984,12 @@ async def process_llm_request(
     skills_xml = prompt.format_skills_as_xml(skills)
     instructions = []
     instructions.append(_DEFAULT_SKILL_SYSTEM_INSTRUCTION)
+    if self._registry:
+      instructions.append(
+          "\nYou can also use the `search_skills` tool to discover additional"
+          " skills in the registry if the available skills listed below are"
+          " not sufficient.\n"
+      )
     instructions.append(skills_xml)
     llm_request.append_instructions(instructions)