Address review feedback: add allOf handling, align Vertex AI empty params, add integration tests

- Add "allOf" to the sanitizer loop alongside anyOf/oneOf so allOf
  schemas are handled instead of passing through unsanitized
- Guard Vertex AI parameters construction when metadata.parameters is
  empty, aligning behavior with the Google AI version
- Add allOf unit tests (with and without null variants)
- Add edge-case tests: all-null type list, all-null anyOf, variant
  with its own description
- Add integration tests for both Google AI and Vertex AI format
  functions to prove end-to-end sanitization

Author: weiguangli-io

python/semantic_kernel/connectors/ai/google/shared_utils.py

@@ -79,8 +79,8 @@ def _sanitize_node(node: dict[str, Any]) -> dict[str, Any]:
             node["nullable"] = True
         node["type"] = non_null[0] if non_null else "string"
 
-    # --- handle ``anyOf`` / ``oneOf`` ---
-    for key in ("anyOf", "oneOf"):
+    # --- handle ``anyOf`` / ``oneOf`` / ``allOf`` ---
+    for key in ("anyOf", "oneOf", "allOf"):
         variants = node.get(key)
         if not variants:
             continue

python/semantic_kernel/connectors/ai/google/vertex_ai/services/utils.py

@@ -2,7 +2,7 @@
 
 import json
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from google.cloud.aiplatform_v1beta1.types.content import Candidate
 from vertexai.generative_models import FunctionDeclaration, Part, Tool, ToolConfig
@@ -136,10 +136,11 @@ def format_tool_message(message: ChatMessageContent) -> list[Part]:
 
 def kernel_function_metadata_to_vertex_ai_function_call_format(metadata: KernelFunctionMetadata) -> FunctionDeclaration:
     """Convert the kernel function metadata to function calling format."""
-    properties = {}
-    for param in metadata.parameters:
-        prop_schema = sanitize_schema_for_google_ai(param.schema_data) if param.schema_data else param.schema_data
-        properties[param.name] = prop_schema
+    properties: dict[str, Any] = {}
+    if metadata.parameters:
+        for param in metadata.parameters:
+            prop_schema = sanitize_schema_for_google_ai(param.schema_data) if param.schema_data else param.schema_data
+            properties[param.name] = prop_schema
     return FunctionDeclaration(
         name=metadata.custom_fully_qualified_name(GEMINI_FUNCTION_NAME_SEPARATOR),
         description=metadata.description or "",

python/tests/unit/connectors/ai/google/google_ai/services/test_google_ai_utils.py

@@ -7,6 +7,7 @@
     finish_reason_from_google_ai_to_semantic_kernel,
     format_assistant_message,
     format_user_message,
+    kernel_function_metadata_to_google_ai_function_call_format,
 )
 from semantic_kernel.contents.chat_message_content import ChatMessageContent
 from semantic_kernel.contents.function_call_content import FunctionCallContent
@@ -16,6 +17,8 @@
 from semantic_kernel.contents.utils.author_role import AuthorRole
 from semantic_kernel.contents.utils.finish_reason import FinishReason as SemanticKernelFinishReason
 from semantic_kernel.exceptions.service_exceptions import ServiceInvalidRequestError
+from semantic_kernel.functions.kernel_function_metadata import KernelFunctionMetadata
+from semantic_kernel.functions.kernel_parameter_metadata import KernelParameterMetadata
 
 
 def test_finish_reason_from_google_ai_to_semantic_kernel():
@@ -113,3 +116,42 @@ def test_format_assistant_message_with_unsupported_items() -> None:
 
     with pytest.raises(ServiceInvalidRequestError):
         format_assistant_message(assistant_message)
+
+
+def test_google_ai_function_call_format_sanitizes_anyof_schema() -> None:
+    """Integration test: anyOf in param schema_data is sanitized in the output dict."""
+    metadata = KernelFunctionMetadata(
+        name="test_func",
+        description="A test function",
+        is_prompt=False,
+        parameters=[
+            KernelParameterMetadata(
+                name="messages",
+                description="The user messages",
+                is_required=True,
+                schema_data={
+                    "anyOf": [
+                        {"type": "string"},
+                        {"type": "array", "items": {"type": "string"}},
+                    ],
+                    "description": "The user messages",
+                },
+            ),
+        ],
+    )
+    result = kernel_function_metadata_to_google_ai_function_call_format(metadata)
+    param_schema = result["parameters"]["properties"]["messages"]
+    assert "anyOf" not in param_schema
+    assert param_schema["type"] == "string"
+
+
+def test_google_ai_function_call_format_empty_parameters() -> None:
+    """Integration test: metadata with no parameters produces parameters=None."""
+    metadata = KernelFunctionMetadata(
+        name="no_params_func",
+        description="No parameters",
+        is_prompt=False,
+        parameters=[],
+    )
+    result = kernel_function_metadata_to_google_ai_function_call_format(metadata)
+    assert result["parameters"] is None

python/tests/unit/connectors/ai/google/test_shared_utils.py

@@ -211,3 +211,56 @@ def test_sanitize_schema_agent_messages_param():
     assert "anyOf" not in result
     assert result["type"] == "string"
     assert result["description"] == "The user messages for the agent."
+
+
+def test_sanitize_schema_allof():
+    """allOf should be handled like anyOf/oneOf, picking the first variant."""
+    schema = {
+        "allOf": [
+            {"type": "object", "properties": {"name": {"type": "string"}}},
+            {"type": "object", "properties": {"age": {"type": "integer"}}},
+        ],
+    }
+    result = sanitize_schema_for_google_ai(schema)
+    assert "allOf" not in result
+    assert result["type"] == "object"
+    assert "name" in result["properties"]
+
+
+def test_sanitize_schema_allof_with_null():
+    """allOf with a null variant should produce nullable: true."""
+    schema = {
+        "allOf": [{"type": "string"}, {"type": "null"}],
+    }
+    result = sanitize_schema_for_google_ai(schema)
+    assert "allOf" not in result
+    assert result["type"] == "string"
+    assert result["nullable"] is True
+
+
+def test_sanitize_schema_all_null_type_list():
+    """type: ["null"] should fall back to type: "string" + nullable: true."""
+    schema = {"type": ["null"]}
+    result = sanitize_schema_for_google_ai(schema)
+    assert result == {"type": "string", "nullable": True}
+
+
+def test_sanitize_schema_all_null_anyof():
+    """anyOf where all variants are null should fall back to type: "string"."""
+    schema = {"anyOf": [{"type": "null"}]}
+    result = sanitize_schema_for_google_ai(schema)
+    assert result == {"type": "string", "nullable": True}
+
+
+def test_sanitize_schema_chosen_variant_keeps_own_description():
+    """When the chosen anyOf variant has its own description, do not overwrite it."""
+    schema = {
+        "anyOf": [
+            {"type": "string", "description": "inner desc"},
+            {"type": "null"},
+        ],
+        "description": "outer desc",
+    }
+    result = sanitize_schema_for_google_ai(schema)
+    assert result["description"] == "inner desc"
+    assert result["nullable"] is True

python/tests/unit/connectors/ai/google/vertex_ai/services/test_vertex_ai_utils.py

@@ -2,12 +2,13 @@
 
 import pytest
 from google.cloud.aiplatform_v1beta1.types.content import Candidate
-from vertexai.generative_models import Part
+from vertexai.generative_models import FunctionDeclaration, Part
 
 from semantic_kernel.connectors.ai.google.vertex_ai.services.utils import (
     finish_reason_from_vertex_ai_to_semantic_kernel,
     format_assistant_message,
     format_user_message,
+    kernel_function_metadata_to_vertex_ai_function_call_format,
 )
 from semantic_kernel.contents.chat_message_content import ChatMessageContent
 from semantic_kernel.contents.function_call_content import FunctionCallContent
@@ -17,6 +18,8 @@
 from semantic_kernel.contents.utils.author_role import AuthorRole
 from semantic_kernel.contents.utils.finish_reason import FinishReason
 from semantic_kernel.exceptions.service_exceptions import ServiceInvalidRequestError
+from semantic_kernel.functions.kernel_function_metadata import KernelFunctionMetadata
+from semantic_kernel.functions.kernel_parameter_metadata import KernelParameterMetadata
 
 
 def test_finish_reason_from_vertex_ai_to_semantic_kernel():
@@ -110,3 +113,40 @@ def test_format_assistant_message_with_unsupported_items() -> None:
 
     with pytest.raises(ServiceInvalidRequestError):
         format_assistant_message(assistant_message)
+
+
+def test_vertex_ai_function_call_format_sanitizes_anyof_schema() -> None:
+    """Integration test: anyOf in param schema_data is sanitized in the FunctionDeclaration."""
+    metadata = KernelFunctionMetadata(
+        name="test_func",
+        description="A test function",
+        is_prompt=False,
+        parameters=[
+            KernelParameterMetadata(
+                name="messages",
+                description="The user messages",
+                is_required=True,
+                schema_data={
+                    "anyOf": [
+                        {"type": "string"},
+                        {"type": "array", "items": {"type": "string"}},
+                    ],
+                    "description": "The user messages",
+                },
+            ),
+        ],
+    )
+    result = kernel_function_metadata_to_vertex_ai_function_call_format(metadata)
+    assert isinstance(result, FunctionDeclaration)
+
+
+def test_vertex_ai_function_call_format_empty_parameters() -> None:
+    """Integration test: metadata with no parameters produces empty properties, no crash."""
+    metadata = KernelFunctionMetadata(
+        name="no_params_func",
+        description="No parameters",
+        is_prompt=False,
+        parameters=[],
+    )
+    result = kernel_function_metadata_to_vertex_ai_function_call_format(metadata)
+    assert isinstance(result, FunctionDeclaration)