Python: pass explicit None to optional kernel function parameters unchanged - #14764

Title: Python: skip type coercion for None arguments in KernelFunctionFromMethod

Motivation and Context

KernelFunctionFromMethod.gather_function_parameters passes every supplied argument through _parse_parameter, which calls the parameter's type on the value. When an argument is present but explicitly None, this goes wrong for optional parameters:

• count: int | None = None gets int(None), which raises TypeError. The call fails with FunctionExecutionException: Parameter count is expected to be parsed to <class 'int'> but is not.
• label: str | None = None gets str(None), so the function receives the string "None" instead of None.
• item: MyDataclass | None = None gets MyDataclass(None) and fails.

This happens when a caller passes None directly. It also happens during auto function calling, where a model sends null for an optional tool parameter ({"count": null}). Instead of running the tool with None, the invocation fails.

Minimal repro:

from semantic_kernel import Kernel
from semantic_kernel.functions import KernelArguments, kernel_function

@kernel_function
def search(query: str, limit: int | None = None) -> str:
    return f"{query}:{limit}"

kernel = Kernel()
func = kernel.add_function(plugin_name="demo", function=search)
await kernel.invoke(func, KernelArguments(query="x", limit=None))
# KernelInvokeException <- FunctionExecutionException: Parameter limit is expected to be parsed to <class 'int'> but is not.

The .NET side has a similar report for null optional arguments (#14652).

Description

In gather_function_parameters, a None value now skips the type coercion step and is passed to the method unchanged. Non-None values are coerced exactly as before, so "3" still becomes 3 for an int parameter.

Test added in tests/unit/functions/test_kernel_function_from_method.py:

• test_explicit_none_for_optional_parameters_is_not_coerced invokes a function with optional int | None, Annotated[str | None, ...] and dataclass | None parameters set to None, and checks that each one receives None. It also checks that string-to-int coercion still works for non-None values.

Without the fix the test fails: the int and dataclass parameters raise, and the str parameter would receive "None".

Tests: tests/unit/functions/test_kernel_function_from_method.py passes (73 tests). The new test_explicit_none_for_optional_parameters_is_not_coerced fails on main and passes with the change. ruff check and mypy are clean on the changed file.

Contribution Checklist

• The code builds clean without any errors or warnings
• The PR follows the SK Contribution Guidelines and the pre-submission formatting script raises no violations
• All unit tests pass, and I have added new tests where possible
• I didn't break anyone 😄

This change was prepared with the help of an AI assistant (Claude), and I reviewed and tested it.