fix(functions): allow arbitrary classes in union argument validation

TypeAdapter rejected unions that include ordinary Python classes before
validating the selected branch, so a valid str or custom instance passed to
a parameter annotated Custom | str raised FunctionExecutionException.
Configure the adapter with arbitrary_types_allowed and add regressions for
the valid primitive, the valid custom instance, and the still-rejected
invalid argument.

Signed-off-by: Adil Alperen Ciftci <adilalperenciftci@users.noreply.github.com>

Author: adilalperenciftci

python/semantic_kernel/functions/kernel_function_from_method.py

@@ -6,7 +6,7 @@
 from inspect import isasyncgen, isasyncgenfunction, isawaitable, iscoroutinefunction, isgenerator, isgeneratorfunction
 from typing import Any, get_origin
 
-from pydantic import Field, TypeAdapter, ValidationError
+from pydantic import ConfigDict, Field, TypeAdapter, ValidationError
 
 from semantic_kernel.exceptions import FunctionExecutionException, FunctionInitializationError
 from semantic_kernel.filters.functions.function_invocation_context import FunctionInvocationContext
@@ -142,7 +142,8 @@ def _parse_parameter(self, value: Any, param_type: Any) -> Any:
         else:
             if get_origin(param_type) is not None:
                 try:
-                    return TypeAdapter(param_type).validate_python(value)
+                    adapter = TypeAdapter(param_type, config=ConfigDict(arbitrary_types_allowed=True))
+                    return adapter.validate_python(value)
                 except Exception as exc:
                     raise FunctionExecutionException(
                         f"Parameter is expected to be parsed to {param_type} but is not."

python/tests/unit/functions/test_kernel_function_from_method.py

@@ -918,3 +918,53 @@ def union_function(value: int | str) -> int | str:
     result = await function.invoke(kernel=kernel, arguments=KernelArguments(value=value))
 
     assert result.value == value
+
+
+class CustomArgument:
+    """Plain Python class used to verify arbitrary types survive union validation."""
+
+    def __init__(self, label: str) -> None:
+        self.label = label
+
+
+async def test_function_invoke_accepts_valid_primitive_in_custom_union(kernel: Kernel):
+    @kernel_function
+    def custom_union_function(value: CustomArgument | str) -> str:
+        return value if isinstance(value, str) else value.label
+
+    function = KernelFunction.from_method(custom_union_function, "test")
+    result = await function.invoke(kernel=kernel, arguments=KernelArguments(value="plain"))
+
+    assert result.value == "plain"
+
+
+async def test_function_invoke_accepts_custom_instance_in_custom_union(kernel: Kernel):
+    @kernel_function
+    def custom_union_function(value: CustomArgument | str) -> str:
+        return value if isinstance(value, str) else value.label
+
+    function = KernelFunction.from_method(custom_union_function, "test")
+    instance = CustomArgument("instance")
+    result = await function.invoke(kernel=kernel, arguments=KernelArguments(value=instance))
+
+    assert result.value == "instance"
+
+
+async def test_function_invoke_rejects_invalid_custom_union_argument(kernel: Kernel):
+    invoked = False
+
+    @kernel_function
+    def custom_union_function(value: CustomArgument | str) -> str:
+        nonlocal invoked
+        invoked = True
+        return value if isinstance(value, str) else value.label
+
+    function = KernelFunction.from_method(custom_union_function, "test")
+
+    with pytest.raises(
+        FunctionExecutionException,
+        match=r"Parameter value is expected to be parsed to .* but is not\.",
+    ):
+        await function.invoke(kernel=kernel, arguments=KernelArguments(value={"unexpected": "value"}))
+
+    assert not invoked