Python: Fix default result_parser arity on kernel function strategies (#14595)

### Motivation and Context

`KernelFunctionSelectionStrategy` and
`KernelFunctionTerminationStrategy` declare optional `result_parser`
fields whose defaults are zero-argument lambdas, but `select_agent` /
`should_agent_terminate` always call `self.result_parser(result)` with
one argument. Using either strategy without a custom parser therefore
always raises `TypeError`.

Fixes #14589

### Description

Update the defaults so they accept the function result:

- **Selection:** `lambda result: str(result).strip()` — use the function
output as the agent name (aligned with the .NET default that reads a
string from the result).
- **Termination:** `lambda result: str(result).strip().lower() ==
"true"` — treat a case-insensitive `"true"` as terminate.

For termination, .NET’s default is `(_) => true` (always terminate). I
followed the issue’s suggestion instead, because an always-true default
would ignore the kernel function output and stop the chat on the first
check. Happy to switch to `lambda _: True` for .NET parity if
maintainers prefer that.

Also adds regression tests that construct both strategies without a
custom `result_parser`.

### Contribution Checklist

- [x] The code builds clean without any errors or warnings
- [x] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [x] All unit tests pass, and I have added new tests where possible
- [x] I didn't break anyone 😄

Co-authored-by: Li-john1021 <li-john1021@users.noreply.github.com>

Author: Li-john1021

python/semantic_kernel/agents/strategies/selection/kernel_function_selection_strategy.py

@@ -41,7 +41,7 @@ class KernelFunctionSelectionStrategy(SelectionStrategy):
     arguments: KernelArguments | None = None
     function: KernelFunction
     kernel: Kernel
-    result_parser: Callable[..., str] = Field(default_factory=lambda: (lambda: ""))
+    result_parser: Callable[..., str] = Field(default_factory=lambda: (lambda result: str(result).strip()))
     history_reducer: ChatHistoryReducer | None = None
 
     @override

python/semantic_kernel/agents/strategies/termination/kernel_function_termination_strategy.py

@@ -33,7 +33,9 @@ class KernelFunctionTerminationStrategy(TerminationStrategy):
     arguments: KernelArguments | None = None
     function: KernelFunction
     kernel: Kernel
-    result_parser: Callable[..., bool] = Field(default_factory=lambda: (lambda: True))
+    result_parser: Callable[..., bool] = Field(
+        default_factory=lambda: (lambda result: str(result).strip().lower() == "true")
+    )
     history_reducer: ChatHistoryReducer | None = None
 
     async def should_agent_terminate(

python/tests/unit/agents/test_group_chat_strategies/test_kernel_function_selection_strategy.py

@@ -104,3 +104,20 @@ async def async_result_parser(result):
 
     assert selected_agent.name == "Agent_2"
     mock_function.invoke.assert_awaited_once()
+
+
+async def test_kernel_function_selection_default_result_parser(agents):
+    """Default result_parser must accept the function result (regression for #14589)."""
+    history = [MagicMock(spec=ChatMessageContent)]
+    mock_function = AsyncMock(spec=KernelFunction)
+    mock_result = MagicMock()
+    mock_result.__str__.return_value = "Agent_1"
+    mock_function.invoke.return_value = mock_result
+    mock_kernel = MagicMock(spec=Kernel)
+
+    strategy = KernelFunctionSelectionStrategy(function=mock_function, kernel=mock_kernel)
+
+    selected_agent = await strategy.next(agents, history)
+
+    assert selected_agent.name == "Agent_1"
+    mock_function.invoke.assert_awaited_once()

python/tests/unit/agents/test_group_chat_strategies/test_kernel_function_termination_strategy.py

@@ -112,3 +112,41 @@ async def mock_result_parser(result):
 
     assert result is True
     mock_function.invoke.assert_awaited_once()
+
+
+async def test_should_agent_terminate_default_result_parser_true():
+    """Default result_parser must accept the function result (regression for #14589)."""
+    agent = MockAgent(id="test-agent-id")
+    history = [MagicMock(spec=ChatMessageContent)]
+
+    mock_function = AsyncMock(spec=KernelFunction)
+    mock_result = MagicMock()
+    mock_result.__str__.return_value = "true"
+    mock_function.invoke.return_value = mock_result
+    mock_kernel = MagicMock(spec=Kernel)
+
+    strategy = KernelFunctionTerminationStrategy(agents=[agent], function=mock_function, kernel=mock_kernel)
+
+    result = await strategy.should_agent_terminate(agent, history)
+
+    assert result is True
+    mock_function.invoke.assert_awaited_once()
+
+
+async def test_should_agent_terminate_default_result_parser_false():
+    """Default result_parser treats non-true strings as continue."""
+    agent = MockAgent(id="test-agent-id")
+    history = [MagicMock(spec=ChatMessageContent)]
+
+    mock_function = AsyncMock(spec=KernelFunction)
+    mock_result = MagicMock()
+    mock_result.__str__.return_value = "no"
+    mock_function.invoke.return_value = mock_result
+    mock_kernel = MagicMock(spec=Kernel)
+
+    strategy = KernelFunctionTerminationStrategy(agents=[agent], function=mock_function, kernel=mock_kernel)
+
+    result = await strategy.should_agent_terminate(agent, history)
+
+    assert result is False
+    mock_function.invoke.assert_awaited_once()