From ebfdc294f516b97b92d1b17db9c96090bdcdc930 Mon Sep 17 00:00:00 2001 From: KVR Vishnu <46535652+VISHNU0906@users.noreply.github.com> Date: Sat, 7 Nov 2026 03:05:41 +0530 Subject: [PATCH 1/2] Python: fix stop_process so processes actually stop stop_process linked the edge under the literal key "END" and EndStep used a random id, so the local runtime never saw END_PROCESS_ID. The inner-loop break also left the outer superstep loop running. Link under the event id, pin EndStep.id to END_STEP_ID, and leave the outer loop after finishing the current superstep. Fixes #14730 Signed-off-by: KVR Vishnu <46535652+VISHNU0906@users.noreply.github.com> --- .../processes/local_runtime/local_process.py | 8 +- .../processes/process_end_step.py | 2 + .../processes/process_step_edge_builder.py | 2 +- .../local_runtime/test_local_process_stop.py | 78 +++++++++++++++++++ .../test_process_step_edge_builder.py | 2 +- 5 files changed, 89 insertions(+), 3 deletions(-) create mode 100644 python/tests/unit/processes/local_runtime/test_local_process_stop.py diff --git a/python/semantic_kernel/processes/local_runtime/local_process.py b/python/semantic_kernel/processes/local_runtime/local_process.py index 601a7240b21e..4402f87a15c9 100644 --- a/python/semantic_kernel/processes/local_runtime/local_process.py +++ b/python/semantic_kernel/processes/local_runtime/local_process.py @@ -207,16 +207,22 @@ async def internal_execute(self, max_supersteps: int = 100, keep_alive: bool = T if not messages_to_process and (not keep_alive or self.external_event_queue.empty()): break + end_message_sent = False message_tasks = [] for message in messages_to_process: if message.destination_id == END_PROCESS_ID: - break + end_message_sent = True + continue destination_step = next(step for step in self.steps if step.id == message.destination_id) message_tasks.append(destination_step.handle_message(message)) await asyncio.gather(*message_tasks) + if end_message_sent: + # A step asked to stop the process: finish this superstep, then stop. + break + except Exception as ex: logger.error(f"An error occurred while running the process: {ex}.") raise diff --git a/python/semantic_kernel/processes/process_end_step.py b/python/semantic_kernel/processes/process_end_step.py index c8806d8700e8..f72dd3bda44f 100644 --- a/python/semantic_kernel/processes/process_end_step.py +++ b/python/semantic_kernel/processes/process_end_step.py @@ -37,6 +37,8 @@ def __init__(self): super().__init__( name=self.END_STEP_VALUE, ) + # The runtimes recognize the end of the process by this id, so it must not be random. + self.id = self.END_STEP_ID def get_function_metadata_map( self, plugin_type, name: str | None = None, kernel: "Kernel | None" = None diff --git a/python/semantic_kernel/processes/process_step_edge_builder.py b/python/semantic_kernel/processes/process_step_edge_builder.py index e42422914f6f..6622f02d8351 100644 --- a/python/semantic_kernel/processes/process_step_edge_builder.py +++ b/python/semantic_kernel/processes/process_step_edge_builder.py @@ -62,7 +62,7 @@ def stop_process(self): ) output_target = ProcessFunctionTargetBuilder(EndStep.get_instance()) self.target = output_target - self.source.link_to("END", self) + self.source.link_to(self.event_id, self) def build(self) -> KernelProcessEdge: """Builds the KernelProcessEdge.""" diff --git a/python/tests/unit/processes/local_runtime/test_local_process_stop.py b/python/tests/unit/processes/local_runtime/test_local_process_stop.py new file mode 100644 index 000000000000..d0bbf51c5381 --- /dev/null +++ b/python/tests/unit/processes/local_runtime/test_local_process_stop.py @@ -0,0 +1,78 @@ +# Copyright (c) Microsoft. All rights reserved. + +from semantic_kernel import Kernel +from semantic_kernel.functions import kernel_function +from semantic_kernel.processes.const import END_PROCESS_ID +from semantic_kernel.processes.kernel_process.kernel_process_step import KernelProcessStep +from semantic_kernel.processes.kernel_process.kernel_process_step_context import KernelProcessStepContext +from semantic_kernel.processes.local_runtime.local_event import KernelProcessEvent +from semantic_kernel.processes.local_runtime.local_kernel_process import start +from semantic_kernel.processes.process_builder import ProcessBuilder +from semantic_kernel.processes.process_end_step import EndStep + +CALLS: list[str] = [] + + +class LoopStep(KernelProcessStep): + """Sends its input on to the worker and asks to stop the process, every time it runs.""" + + @kernel_function + async def run(self, value: str, context: KernelProcessStepContext) -> None: + CALLS.append("run") + await context.emit_event("Work", data=value) + await context.emit_event("Exit", data=None) + + +class WorkerStep(KernelProcessStep): + """Sends its input back to the loop step.""" + + @kernel_function + async def work(self, value: str) -> str: + CALLS.append("work") + return value + + +def _build_loop(stop_with_event: str = "Exit"): + builder = ProcessBuilder(name="stopper") + loop_step = builder.add_step(LoopStep) + worker_step = builder.add_step(WorkerStep) + builder.on_input_event("go").send_event_to(loop_step, function_name="run", parameter_name="value") + loop_step.on_event("Work").send_event_to(worker_step, function_name="work", parameter_name="value") + loop_step.on_event(stop_with_event).stop_process() + worker_step.on_function_result("work").send_event_to(loop_step, function_name="run", parameter_name="value") + return builder, loop_step + + +def test_end_step_id_is_the_end_process_id(): + assert EndStep.get_instance().id == END_PROCESS_ID + + +def test_stop_process_edge_is_registered_for_the_event_it_was_set_on(): + builder, loop_step = _build_loop() + + process = builder.build() + + edges = next(step.output_edges for step in process.steps if step.state.name == "LoopStep") + assert "END" not in edges + assert [edge.output_target.step_id for edge in edges[loop_step.get_scoped_event_id("Exit")]] == [END_PROCESS_ID] + + +async def test_stop_process_ends_a_process_that_would_loop(): + CALLS.clear() + builder, _ = _build_loop() + + await start(process=builder.build(), kernel=Kernel(), initial_event=KernelProcessEvent(id="go", data="x")) + + # The worker message that was sent in the same superstep as the stop still runs, then the process ends. + assert CALLS == ["run", "work"] + + +async def test_process_without_stop_process_keeps_looping_until_the_superstep_limit(): + CALLS.clear() + builder, _ = _build_loop(stop_with_event="Unused") + + await start( + process=builder.build(), kernel=Kernel(), initial_event=KernelProcessEvent(id="go", data="x"), max_supersteps=6 + ) + + assert CALLS == ["run", "work", "run", "work", "run", "work"] diff --git a/python/tests/unit/processes/test_process_step_edge_builder.py b/python/tests/unit/processes/test_process_step_edge_builder.py index 32d721775215..803f077c8fc9 100644 --- a/python/tests/unit/processes/test_process_step_edge_builder.py +++ b/python/tests/unit/processes/test_process_step_edge_builder.py @@ -99,7 +99,7 @@ def test_stop_process(): # Assert assert edge_builder.target is not None assert edge_builder.target.function_name == "END" - source.link_to.assert_called_once_with("END", edge_builder) + source.link_to.assert_called_once_with(event_id, edge_builder) def test_build(): From d61d7898529b506056765a5a2f8196f02893b47e Mon Sep 17 00:00:00 2001 From: KVR Vishnu <46535652+VISHNU0906@users.noreply.github.com> Date: Sat, 7 Nov 2026 05:07:20 +0530 Subject: [PATCH 2/2] Python: drain final superstep events before stop_process break When end_message_sent breaks the local process loop, handlers in that superstep may still have outgoing events. Drain them so public events reach a parent nested process, without running another superstep. Signed-off-by: KVR Vishnu <46535652+VISHNU0906@users.noreply.github.com> --- .../processes/local_runtime/local_process.py | 5 +- .../local_runtime/test_local_process_stop.py | 47 +++++++++++++++++++ 2 files changed, 51 insertions(+), 1 deletion(-) diff --git a/python/semantic_kernel/processes/local_runtime/local_process.py b/python/semantic_kernel/processes/local_runtime/local_process.py index 4402f87a15c9..7c42100cd658 100644 --- a/python/semantic_kernel/processes/local_runtime/local_process.py +++ b/python/semantic_kernel/processes/local_runtime/local_process.py @@ -220,7 +220,10 @@ async def internal_execute(self, max_supersteps: int = 100, keep_alive: bool = T await asyncio.gather(*message_tasks) if end_message_sent: - # A step asked to stop the process: finish this superstep, then stop. + # Handlers in this superstep may have emitted events. Drain them so public + # events reach a parent nested process, but do not run another superstep. + for step in self.steps: + await self.enqueue_step_messages(step, message_channel) break except Exception as ex: diff --git a/python/tests/unit/processes/local_runtime/test_local_process_stop.py b/python/tests/unit/processes/local_runtime/test_local_process_stop.py index d0bbf51c5381..b9641088e9ee 100644 --- a/python/tests/unit/processes/local_runtime/test_local_process_stop.py +++ b/python/tests/unit/processes/local_runtime/test_local_process_stop.py @@ -3,6 +3,7 @@ from semantic_kernel import Kernel from semantic_kernel.functions import kernel_function from semantic_kernel.processes.const import END_PROCESS_ID +from semantic_kernel.processes.kernel_process.kernel_process_event import KernelProcessEventVisibility from semantic_kernel.processes.kernel_process.kernel_process_step import KernelProcessStep from semantic_kernel.processes.kernel_process.kernel_process_step_context import KernelProcessStepContext from semantic_kernel.processes.local_runtime.local_event import KernelProcessEvent @@ -76,3 +77,49 @@ async def test_process_without_stop_process_keeps_looping_until_the_superstep_li ) assert CALLS == ["run", "work", "run", "work", "run", "work"] + + +NESTED_SEEN: list[str] = [] + + +class _NestedStartStep(KernelProcessStep): + @kernel_function + async def run(self, value: str, context: KernelProcessStepContext) -> None: + await context.emit_event("Work", data=value) + await context.emit_event("Exit", data=None) + + +class _NestedWorkerStep(KernelProcessStep): + @kernel_function + async def work(self, value: str, context: KernelProcessStepContext) -> None: + # Emitted in the same superstep as the end message is processed. + await context.emit_event("Result", data=value, visibility=KernelProcessEventVisibility.Public) + + +class _OuterSinkStep(KernelProcessStep): + @kernel_function + async def take(self, value: str) -> str: + NESTED_SEEN.append(value) + return value + + +async def test_stop_process_forwards_nested_public_events_from_final_superstep(): + """A nested process that stops still forwards public events from its final superstep.""" + NESTED_SEEN.clear() + + inner = ProcessBuilder(name="Inner") + start_step = inner.add_step(_NestedStartStep) + worker = inner.add_step(_NestedWorkerStep) + inner.on_input_event("go").send_event_to(start_step, function_name="run", parameter_name="value") + start_step.on_event("Work").send_event_to(worker, function_name="work", parameter_name="value") + start_step.on_event("Exit").stop_process() + + outer = ProcessBuilder(name="Outer") + nested = outer.add_step_from_process(inner) + sink = outer.add_step(_OuterSinkStep) + outer.on_input_event("go").send_event_to(nested.where_input_event_is("go")) + nested.on_event("Result").send_event_to(sink, function_name="take", parameter_name="value") + + await start(process=outer.build(), kernel=Kernel(), initial_event=KernelProcessEvent(id="go", data="hello")) + + assert NESTED_SEEN == ["hello"]