Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -207,16 +207,25 @@ 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:
# 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:
logger.error(f"An error occurred while running the process: {ex}.")
raise
Expand Down
2 changes: 2 additions & 0 deletions python/semantic_kernel/processes/process_end_step.py
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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."""
Expand Down
125 changes: 125 additions & 0 deletions python/tests/unit/processes/local_runtime/test_local_process_stop.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,125 @@
# 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_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
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"]


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"]
Original file line number Diff line number Diff line change
Expand Up @@ -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():
Expand Down
Loading