Merge branch 'main' into feat/a2a-preserve-session-identity

Author: KrshnKush

src/google/adk/cli/cli_deploy.py

@@ -771,25 +771,27 @@ def to_agent_engine(
         )
       agent_config['description'] = description
 
-    if not requirements_file:
+    requirements_txt_path = os.path.join(agent_src_path, 'requirements.txt')
+    if requirements_file:
+      if os.path.exists(requirements_txt_path):
+        click.echo(
+            f'Overwriting {requirements_txt_path} with {requirements_file}'
+        )
+      shutil.copyfile(requirements_file, requirements_txt_path)
+    elif 'requirements_file' in agent_config:
+      if os.path.exists(requirements_txt_path):
+        click.echo(
+            f'Overwriting {requirements_txt_path} with'
+            f' {agent_config["requirements_file"]}'
+        )
+      shutil.copyfile(agent_config['requirements_file'], requirements_txt_path)
+    else:
       # Attempt to read requirements from requirements.txt in the dir (if any).
-      requirements_txt_path = os.path.join(agent_src_path, 'requirements.txt')
       if not os.path.exists(requirements_txt_path):
         click.echo(f'Creating {requirements_txt_path}...')
         with open(requirements_txt_path, 'w', encoding='utf-8') as f:
           f.write('google-cloud-aiplatform[adk,agent_engines]')
         click.echo(f'Created {requirements_txt_path}')
-      agent_config['requirements_file'] = agent_config.get(
-          'requirements',
-          requirements_txt_path,
-      )
-    else:
-      if 'requirements_file' in agent_config:
-        click.echo(
-            'Overriding requirements in agent engine config with '
-            f'{requirements_file}'
-        )
-      agent_config['requirements_file'] = requirements_file
     agent_config['requirements_file'] = f'{temp_folder}/requirements.txt'
 
     env_vars = {}

src/google/adk/tools/_gemini_schema_util.py

@@ -74,6 +74,35 @@ def _to_snake_case(text: str) -> str:
   return text
 
 
+def _sanitize_schema_type(
+    schema: dict[str, Any], preserve_null_type: bool = False
+) -> dict[str, Any]:
+  if not schema:
+    schema["type"] = "object"
+  if isinstance(schema.get("type"), list):
+    types_no_null = [t for t in schema["type"] if t != "null"]
+    nullable = len(types_no_null) != len(schema["type"])
+    if "array" in types_no_null:
+      non_null_type = "array"
+    else:
+      non_null_type = types_no_null[0] if types_no_null else "object"
+    if nullable:
+      schema["type"] = [non_null_type, "null"]
+    else:
+      schema["type"] = non_null_type
+  elif schema.get("type") == "null" and not preserve_null_type:
+    schema["type"] = ["object", "null"]
+
+  schema_type = schema.get("type")
+  is_array = schema_type == "array" or (
+      isinstance(schema_type, list) and "array" in schema_type
+  )
+  if is_array:
+    schema.setdefault("items", {"type": "string"})
+
+  return schema
+
+
 def _dereference_schema(schema: dict[str, Any]) -> dict[str, Any]:
   """Resolves $ref pointers in a JSON schema."""
 
@@ -113,7 +142,7 @@ def _resolve_refs(sub_schema: Any) -> Any:
 
 
 def _sanitize_schema_formats_for_gemini(
-    schema: dict[str, Any],
+    schema: dict[str, Any], preserve_null_type: bool = False
 ) -> dict[str, Any]:
   """Filters the schema to only include fields that are supported by JSONSchema."""
   supported_fields: set[str] = set(_ExtendedJSONSchema.model_fields.keys())
@@ -135,8 +164,12 @@ def _sanitize_schema_formats_for_gemini(
           field_value
       )
     elif field_name in list_schema_field_names:
+      should_preserve = field_name in ("any_of", "one_of")
       snake_case_schema[field_name] = [
-          _sanitize_schema_formats_for_gemini(value) for value in field_value
+          _sanitize_schema_formats_for_gemini(
+              value, preserve_null_type=should_preserve
+          )
+          for value in field_value
       ]
     elif field_name in dict_schema_field_names and field_value is not None:
       snake_case_schema[field_name] = {
@@ -158,11 +191,7 @@ def _sanitize_schema_formats_for_gemini(
     elif field_name in supported_fields and field_value is not None:
       snake_case_schema[field_name] = field_value
 
-  # If the schema is empty, assume it has the type of object
-  if not snake_case_schema:
-    snake_case_schema["type"] = "object"
-
-  return snake_case_schema
+  return _sanitize_schema_type(snake_case_schema, preserve_null_type)
 
 
 def _to_gemini_schema(openapi_schema: dict[str, Any]) -> Schema:

tests/unittests/tools/test_gemini_schema_util.py

@@ -66,9 +66,15 @@ def test_to_gemini_schema_array_string_types(self):
             "nullable_string": {"type": ["string", "null"]},
             "nullable_number": {"type": ["null", "integer"]},
             "nullable_object": {"type": ["object", "null"]},
+            "object_nullable": {"type": "null"},
             "multi_types_nullable": {"type": ["string", "null", "integer"]},
             "only_null": {"type": "null"},
             "empty_default_object": {},
+            "empty_list_type": {"type": []},
+            "multi_type_with_array_nullable": {
+                "type": ["string", "array", "null"]
+            },
+            "multi_type_with_array_nonnullable": {"type": ["integer", "array"]},
         },
     }
     gemini_schema = _to_gemini_schema(openapi_schema)
@@ -88,18 +94,38 @@ def test_to_gemini_schema_array_string_types(self):
     assert gemini_schema.properties["nullable_object"].type == Type.OBJECT
     assert gemini_schema.properties["nullable_object"].nullable
 
-    assert gemini_schema.properties["multi_types_nullable"].any_of == [
-        Schema(type=Type.STRING),
-        Schema(type=Type.INTEGER),
-    ]
+    assert gemini_schema.properties["object_nullable"].type == Type.OBJECT
+    assert gemini_schema.properties["object_nullable"].nullable
+
+    assert gemini_schema.properties["multi_types_nullable"].type == Type.STRING
     assert gemini_schema.properties["multi_types_nullable"].nullable
 
-    assert gemini_schema.properties["only_null"].type is None
+    assert gemini_schema.properties["only_null"].type == Type.OBJECT
     assert gemini_schema.properties["only_null"].nullable
 
+    assert gemini_schema.properties["multi_types_nullable"].type == Type.STRING
+    assert gemini_schema.properties["multi_types_nullable"].nullable
+
     assert gemini_schema.properties["empty_default_object"].type == Type.OBJECT
     assert gemini_schema.properties["empty_default_object"].nullable is None
 
+    assert gemini_schema.properties["empty_list_type"].type == Type.OBJECT
+    assert not gemini_schema.properties["empty_list_type"].nullable
+
+    assert (
+        gemini_schema.properties["multi_type_with_array_nullable"].type
+        == Type.ARRAY
+    )
+    assert gemini_schema.properties["multi_type_with_array_nullable"].nullable
+
+    assert (
+        gemini_schema.properties["multi_type_with_array_nonnullable"].type
+        == Type.ARRAY
+    )
+    assert not gemini_schema.properties[
+        "multi_type_with_array_nonnullable"
+    ].nullable
+
   def test_to_gemini_schema_nested_objects(self):
     openapi_schema = {
         "type": "object",
@@ -144,6 +170,20 @@ def test_to_gemini_schema_nested_array(self):
     gemini_schema = _to_gemini_schema(openapi_schema)
     assert gemini_schema.items.properties["name"].type == Type.STRING
 
+  def test_to_gemini_schema_array_without_items_gets_default(self):
+    openapi_schema = {"type": "array"}
+    gemini_schema = _to_gemini_schema(openapi_schema)
+    assert gemini_schema.type == Type.ARRAY
+    assert not gemini_schema.nullable
+    assert gemini_schema.items.type == Type.STRING
+
+  def test_to_gemini_schema_nullable_array_without_items_gets_default(self):
+    openapi_schema = {"type": ["array", "null"]}
+    gemini_schema = _to_gemini_schema(openapi_schema)
+    assert gemini_schema.type == Type.ARRAY
+    assert gemini_schema.nullable
+    assert gemini_schema.items.type == Type.STRING
+
   def test_to_gemini_schema_any_of(self):
     openapi_schema = {
         "anyOf": [{"type": "string"}, {"type": "integer"}],
@@ -200,7 +240,7 @@ def test_to_gemini_schema_nested_dict(self):
         },
     }
     gemini_schema = _to_gemini_schema(openapi_schema)
-    # Since metadata is neither properties nor item, it will call to_gemini_schema recursively.
+    # Since metadata is not properties nor item, it will call to_gemini_schema recursively.
     assert isinstance(gemini_schema.properties["metadata"], Schema)
     assert (
         gemini_schema.properties["metadata"].type == Type.OBJECT
@@ -544,7 +584,7 @@ def test_sanitize_schema_formats_for_gemini_nullable(self):
         "properties": {
             "case_id": {
                 "description": "The ID of the case.",
-                "title": "Case ID",
+                "title": "Case Id",
                 "type": "string",
             },
             "next_page_token": {
@@ -567,7 +607,7 @@ def test_sanitize_schema_formats_for_gemini_nullable(self):
         "properties": {
             "case_id": {
                 "description": "The ID of the case.",
-                "title": "Case ID",
+                "title": "Case Id",
                 "type": "string",
             },
             "next_page_token": {