Merge branch 'main' into feat/add-metadata-parameter

Author: donggyun112

.agents/skills/adk-sample-creator/SKILL.md

@@ -30,11 +30,6 @@ The `agent.py` should focus on demonstrating a specific feature or agent pattern
 > [!IMPORTANT]
 > **Model Selection**: Do not set the `model` parameter explicitly (e.g., `model="gemini-2.5-flash"`) on `Agent` instances in sample agents. Instead, let them default to the system-configured model, unless a specific model is explicitly requested by the user.
 
-> [!IMPORTANT]
-> **Context Usage**: Prefer using the unified `Context` class (imported from
-> `google.adk`) instead of the legacy `ToolContext` or `CallbackContext`
-> aliases in callbacks and tool definitions.
-
 Choose one of the following patterns:
 
 #### Pattern A: Workflows (for complex graphs)

contributing/samples/core/nested_state/README.md

@@ -259,8 +259,19 @@ def _serialize_value(value: Any) -> Optional[Any]:
       logger.warning("Failed to serialize Pydantic model, falling back: %s", e)
       return str(value)
 
-  # Pass through JSON-native types as-is
-  if isinstance(value, (dict, list, int, float, bool, str)):
+  # Recurse into JSON-native containers so nested non-JSON-serializable
+  # values (e.g. datetime) are still stringified, then pass through other
+  # JSON-native scalars as-is.
+  if isinstance(value, dict):
+    # JSON object keys must be strings, so stringify any non-string key to
+    # avoid a downstream TypeError when the metadata is JSON-encoded.
+    return {
+        (k if isinstance(k, str) else str(k)): _serialize_value(v)
+        for k, v in value.items()
+    }
+  if isinstance(value, list):
+    return [_serialize_value(item) for item in value]
+  if isinstance(value, (int, float, bool, str)):
     return value
 
   return str(value)

contributing/samples/core/nested_state/__init__.py

@@ -653,8 +653,9 @@ def convert_events_to_eval_invocations(
         if current_author == _USER_AUTHOR:
           # If the author is the user, then we just identify it and move on
           # to the next event.
-          user_content = event.content
-          invocation_timestamp = event.timestamp
+          if event.content is not None:
+            user_content = event.content
+            invocation_timestamp = event.timestamp
           continue
 
         if event.content and event.content.parts:

contributing/samples/core/nested_state/agent.py

@@ -70,7 +70,9 @@ class DataFileUtil:
 _DATA_FILE_UTIL_MAP = {
     'text/csv': DataFileUtil(
         extension='.csv',
-        loader_code_template="pd.read_csv('{filename}')",
+        # Note: The template does not quote {filename} because repr() in
+        # _get_data_file_preprocessing_code supplies quotes and escaping.
+        loader_code_template='pd.read_csv({filename})',
     ),
 }
 
@@ -529,7 +531,7 @@ def _get_normalized_file_name(file_name: str) -> str:
 
   var_name = _get_normalized_file_name(file.name)
   loader_code = _DATA_FILE_UTIL_MAP[file.mime_type].loader_code_template.format(
-      filename=file.name
+      filename=repr(file.name)
   )
   return f"""
 {_DATA_FILE_HELPER_LIB}

src/google/adk/a2a/converters/from_adk_event.py

@@ -525,7 +525,7 @@ def _convert_reasoning_value_to_parts(reasoning_value: Any) -> List[types.Part]:
         continue
       thinking_text = block.get("thinking", "")
       signature = block.get("signature", "")
-      if not thinking_text:
+      if not thinking_text and not signature:
         continue
       part = types.Part(text=thinking_text, thought=True)
       if signature:

src/google/adk/evaluation/evaluation_generator.py

@@ -26,17 +26,24 @@
 def safe_json_serialize(obj: object) -> str:
   """Convert any Python object to a JSON-serializable type or string.
 
+  Handles Pydantic `BaseModel` instances (common as tool return types) by
+  calling `model_dump(mode="json")` before JSON encoding.
+
   Args:
     obj: The object to serialize.
 
   Returns:
     The JSON-serialized object string or `<not serializable>` if the object
     cannot be serialized.
   """
+
+  def _default(o: object) -> object:
+    if isinstance(o, BaseModel):
+      return o.model_dump(mode="json")
+    return "<not serializable>"
+
   try:
-    return json.dumps(
-        obj, ensure_ascii=False, default=lambda o: "<not serializable>"
-    )
+    return json.dumps(obj, ensure_ascii=False, default=_default)
   except (TypeError, ValueError, OverflowError, RecursionError):
     return "<not serializable>"
 

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

@@ -182,7 +182,7 @@ def _is_default_value_compatible(
       or isinstance(annotation, typing_types.GenericAlias)
       or isinstance(annotation, typing_types.UnionType)
   ):
-    origin = get_origin(annotation)
+    origin: Any = get_origin(annotation)
     if origin in (Union, typing_types.UnionType):
       return any(
           _is_default_value_compatible(default_value, arg)
@@ -208,6 +208,22 @@ def _is_default_value_compatible(
           for item in default_value
       )
 
+    if origin is tuple:
+      if not isinstance(default_value, tuple):
+        return False
+      args = get_args(annotation)
+      if len(args) == 2 and args[-1] is Ellipsis:
+        return all(
+            _is_default_value_compatible(item, args[0])
+            for item in default_value
+        )
+      if len(args) != len(default_value):
+        return False
+      return all(
+          _is_default_value_compatible(item, arg)
+          for item, arg in zip(default_value, args)
+      )
+
     if origin is Literal:
       return default_value in get_args(annotation)
 
@@ -299,7 +315,7 @@ def _parse_schema_from_parameter(
       or isinstance(param.annotation, typing_types.GenericAlias)
       or isinstance(param.annotation, typing_types.UnionType)
   ):
-    origin = get_origin(param.annotation)
+    origin: Any = get_origin(param.annotation)
     args = get_args(param.annotation)
     if origin is dict:
       schema.type = types.Type.OBJECT
@@ -339,6 +355,43 @@ def _parse_schema_from_parameter(
         schema.default = param.default
       _raise_if_schema_unsupported(variant, schema)
       return schema
+    if origin is tuple:
+      # A genai array schema only carries a single `items` type, so only
+      # homogeneous tuples can be represented. `tuple[T, ...]` maps to an
+      # unbounded array, while a fixed-length homogeneous tuple
+      # (e.g. `tuple[T, T]`) additionally pins min_items/max_items to the
+      # arity. Heterogeneous tuples (e.g. `tuple[str, int]`) cannot be
+      # represented and intentionally raise so that from_function_with_options
+      # routes them through the standard unsupported-parameter handling.
+      fixed_length = None
+      if len(args) == 2 and args[-1] is Ellipsis:
+        item_annotation = args[0]
+      elif args and all(arg == args[0] for arg in args):
+        item_annotation = args[0]
+        fixed_length = len(args)
+      else:
+        raise ValueError(
+            f'Tuple type {param.annotation} must use one repeated item type.'
+        )
+      schema.type = types.Type.ARRAY
+      schema.items = _parse_schema_from_parameter(
+          variant,
+          inspect.Parameter(
+              'item',
+              inspect.Parameter.POSITIONAL_OR_KEYWORD,
+              annotation=item_annotation,
+          ),
+          func_name,
+      )
+      if fixed_length is not None:
+        schema.min_items = fixed_length
+        schema.max_items = fixed_length
+      if param.default is not inspect.Parameter.empty:
+        if not _is_default_value_compatible(param.default, param.annotation):
+          raise ValueError(default_value_error_msg)
+        schema.default = param.default
+      _raise_if_schema_unsupported(variant, schema)
+      return schema
     if origin in (Union, typing_types.UnionType):
       schema.any_of = []
       schema.type = types.Type.OBJECT