From e92646422c3afcd80ef14e2f0edf39b2b1ae452b Mon Sep 17 00:00:00 2001 From: Steven Huang <134844631+remote-controlled-man@users.noreply.github.com> Date: Mon, 9 Nov 2026 10:44:15 +0800 Subject: [PATCH 1/3] Python: consume process step inputs before invoking --- .../processes/local_runtime/local_step.py | 7 +-- .../local_runtime/test_local_process.py | 47 +++++++++++++++++++ 2 files changed, 51 insertions(+), 3 deletions(-) diff --git a/python/semantic_kernel/processes/local_runtime/local_step.py b/python/semantic_kernel/processes/local_runtime/local_step.py index 1b6d6e43c2ed..3b9de51fa412 100644 --- a/python/semantic_kernel/processes/local_runtime/local_step.py +++ b/python/semantic_kernel/processes/local_runtime/local_step.py @@ -149,6 +149,10 @@ async def handle_message(self, message: LocalMessage): if function is None: raise ProcessFunctionNotFoundException(f"Function {target_function} not found in plugin {self.name}") + # Consume the complete input set before invoking. Concurrent messages must + # populate a fresh buffer, which this invocation must not reset on completion. + self.inputs[target_function] = self.initial_inputs.get(target_function, {}).copy() + invoke_result = None event_name: str = "" event_value = None @@ -169,9 +173,6 @@ async def handle_message(self, message: LocalMessage): finally: await self.emit_event(KernelProcessEvent(id=event_name, data=event_value)) - # Reset the inputs for the function that was just executed - self.inputs[target_function] = self.initial_inputs.get(target_function, {}).copy() - async def invoke_function(self, function: "KernelFunction", kernel: "Kernel", arguments: dict[str, Any]): """Invokes the function.""" return await kernel.invoke(function, **arguments) diff --git a/python/tests/unit/processes/local_runtime/test_local_process.py b/python/tests/unit/processes/local_runtime/test_local_process.py index 2ac880f9e937..5ba889425b95 100644 --- a/python/tests/unit/processes/local_runtime/test_local_process.py +++ b/python/tests/unit/processes/local_runtime/test_local_process.py @@ -8,6 +8,7 @@ from semantic_kernel.exceptions.kernel_exceptions import KernelException from semantic_kernel.exceptions.process_exceptions import ProcessEventUndefinedException +from semantic_kernel.functions import kernel_function from semantic_kernel.kernel import Kernel from semantic_kernel.processes.kernel_process.kernel_process import KernelProcess from semantic_kernel.processes.kernel_process.kernel_process_edge import KernelProcessEdge @@ -16,10 +17,14 @@ KernelProcessEventVisibility, ) from semantic_kernel.processes.kernel_process.kernel_process_state import KernelProcessState +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.kernel_process.kernel_process_step_info import KernelProcessStepInfo +from semantic_kernel.processes.local_runtime.local_kernel_process import start from semantic_kernel.processes.local_runtime.local_message import LocalMessage from semantic_kernel.processes.local_runtime.local_process import LocalProcess from semantic_kernel.processes.local_runtime.local_step import LocalStep +from semantic_kernel.processes.process_builder import ProcessBuilder @pytest.fixture @@ -356,3 +361,45 @@ def mock_process_with_steps(mock_process, mock_kernel, build_model): local_process.steps = [step_1, step_2] return local_process + + +@pytest.mark.parametrize("defer_second_b", [False, True]) +@pytest.mark.parametrize("fail_first", [False, True]) +async def test_messages_to_same_step_do_not_reuse_inputs_during_invocation(defer_second_b, fail_first): + pairs = [] + + class Producer(KernelProcessStep): + @kernel_function + async def emit(self, context: KernelProcessStepContext) -> None: + for event, value in (("a1", 1), ("b1", 1), ("a2", 2), ("b2", 2)): + await context.emit_event(event, data=value) + + class Join(KernelProcessStep): + @kernel_function + async def join(self, a: int, b: int) -> None: + await asyncio.sleep(0) + pairs.append((a, b)) + if fail_first and a == 1: + raise RuntimeError("first pair failed") + + class Relay(KernelProcessStep): + @kernel_function + async def relay(self, value: int) -> int: + return value + + builder = ProcessBuilder(name="join") + producer = builder.add_step(Producer) + join = builder.add_step(Join) + builder.on_input_event("start").send_event_to(producer, function_name="emit") + for event in ("a1", "b1", "a2", "b2"): + if defer_second_b and event == "b2": + relay = builder.add_step(Relay) + producer.on_event(event).send_event_to(relay, function_name="relay", parameter_name="value") + relay.on_function_result("relay").send_event_to(join, function_name="join", parameter_name="b") + else: + producer.on_event(event).send_event_to(join, function_name="join", parameter_name=event[0]) + + async with await start(builder.build(), Kernel(), initial_event="start"): + pass + + assert pairs == [(1, 1), (2, 2)] From 6dde9aef3b83423f3761b35e0a18a95d1a4a8a37 Mon Sep 17 00:00:00 2001 From: Steven Huang <134844631+remote-controlled-man@users.noreply.github.com> Date: Thu, 12 Nov 2026 23:53:27 +0800 Subject: [PATCH 2/3] test(python): verify serialized Dapr input dispatch --- .../processes/dapr_runtime/test_step_actor.py | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/python/tests/unit/processes/dapr_runtime/test_step_actor.py b/python/tests/unit/processes/dapr_runtime/test_step_actor.py index a89f67065af8..9c381eb83e2f 100644 --- a/python/tests/unit/processes/dapr_runtime/test_step_actor.py +++ b/python/tests/unit/processes/dapr_runtime/test_step_actor.py @@ -1,5 +1,6 @@ # Copyright (c) Microsoft. All rights reserved. +import asyncio import json from typing import cast from unittest.mock import AsyncMock, MagicMock, patch @@ -11,6 +12,8 @@ from semantic_kernel.exceptions.process_exceptions import ( ProcessFunctionNotFoundException, ) +from semantic_kernel.functions import kernel_function +from semantic_kernel.kernel import Kernel from semantic_kernel.processes.dapr_runtime.actors.actor_state_key import ActorStateKeys from semantic_kernel.processes.dapr_runtime.actors.event_buffer_actor import EventBufferActor from semantic_kernel.processes.dapr_runtime.actors.step_actor import StepActor @@ -21,6 +24,7 @@ KernelProcessEventVisibility, ) from semantic_kernel.processes.kernel_process.kernel_process_function_target import KernelProcessFunctionTarget +from semantic_kernel.processes.kernel_process.kernel_process_step import KernelProcessStep from semantic_kernel.processes.kernel_process.kernel_process_step_state import KernelProcessStepState from semantic_kernel.processes.process_event import ProcessEvent from semantic_kernel.processes.process_message import ProcessMessage @@ -122,6 +126,56 @@ async def test_process_incoming_messages(actor_context): mock_try_add_state.assert_any_call("incomingMessagesState", expected_messages) +@pytest.mark.parametrize("defer_second_b", [False, True]) +@pytest.mark.parametrize("fail_first", [False, True]) +async def test_process_incoming_messages_keeps_awaiting_invocations_serial(actor_context, defer_second_b, fail_first): + pairs = [] + + class Join(KernelProcessStep): + @kernel_function + async def join(self, a: int, b: int) -> int: + await asyncio.sleep(0) + pairs.append((a, b)) + if fail_first and a == 1: + raise RuntimeError("first pair failed") + return a + b + + actor_context.kernel = Kernel() + actor_context.factories = {"Join": Join} + proxy = AsyncMock() + messages = [ + ProcessMessage(source_id="source", destination_id="join", function_name="join", values={key: value}) + for key, value in (("a", 1), ("b", 1), ("a", 2), ("b", 2)) + ] + with ( + patch("dapr.actor.ActorProxy.create", return_value=proxy), + patch.object(actor_context._state_manager, "try_add_state", new=AsyncMock()), + patch.object(actor_context._state_manager, "set_state", new=AsyncMock()), + patch.object(actor_context._state_manager, "save_state", new=AsyncMock()), + ): + await actor_context.initialize_step( + json.dumps({ + "step_info": { + "state": {"name": "Join", "version": "1.0", "id": "join"}, + "inner_step_python_type": "Join", + "edges": {}, + }, + }) + ) + first_batch = messages[:-1] if defer_second_b else messages + proxy.dequeue_all.return_value = [message.model_dump_json() for message in first_batch] + assert await actor_context.prepare_incoming_messages() == len(first_batch) + await actor_context.process_incoming_messages() + + if defer_second_b: + assert pairs == [(1, 1)] + proxy.dequeue_all.return_value = [messages[-1].model_dump_json()] + assert await actor_context.prepare_incoming_messages() == 1 + await actor_context.process_incoming_messages() + + assert pairs == [(1, 1), (2, 2)] + + async def test_activate_step_with_factory_creates_state(actor_context): fake_step_instance = FakeStep() fake_step_instance.activate = AsyncMock(side_effect=fake_step_instance.activate) From 1ef82d116cebf88460055efca17babdf335b8c3a Mon Sep 17 00:00:00 2001 From: Steven Huang <134844631+remote-controlled-man@users.noreply.github.com> Date: Thu, 12 Nov 2026 23:59:21 +0800 Subject: [PATCH 3/3] test(python): group local input regressions before fixtures --- .../local_runtime/test_local_process.py | 57 ++++++++++--------- 1 file changed, 29 insertions(+), 28 deletions(-) diff --git a/python/tests/unit/processes/local_runtime/test_local_process.py b/python/tests/unit/processes/local_runtime/test_local_process.py index 5ba889425b95..c170c083c4e8 100644 --- a/python/tests/unit/processes/local_runtime/test_local_process.py +++ b/python/tests/unit/processes/local_runtime/test_local_process.py @@ -18,7 +18,6 @@ ) from semantic_kernel.processes.kernel_process.kernel_process_state import KernelProcessState 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.kernel_process.kernel_process_step_info import KernelProcessStepInfo from semantic_kernel.processes.local_runtime.local_kernel_process import start from semantic_kernel.processes.local_runtime.local_message import LocalMessage @@ -336,36 +335,11 @@ async def test_handle_message_with_valid_event_id(mock_process_with_output_edges END_PROCESS_ID = "END" -@pytest.fixture -def mock_process_with_steps(mock_process, mock_kernel, build_model): - """Fixture to create a LocalProcess with mock steps.""" - local_process = LocalProcess(process=mock_process, kernel=mock_kernel) - - # Create real LocalStep instances - state_1 = MagicMock(spec=KernelProcessState) - state_1.name = "step_1_state" - state_1.id = "step_1_id" - - step_info_1 = MagicMock(spec=KernelProcessStepInfo) - step_info_1.state = state_1 - - state_2 = MagicMock(spec=KernelProcessState) - state_2.name = "step_2_state" - state_2.id = "step_2_id" - - step_info_2 = MagicMock(spec=KernelProcessStepInfo) - step_info_2.state = state_2 - - step_1 = LocalStep(step_info=step_info_1, kernel=mock_kernel, parent_process_id="test_process") - step_2 = LocalStep(step_info=step_info_2, kernel=mock_kernel, parent_process_id="test_process") - - local_process.steps = [step_1, step_2] - return local_process - - @pytest.mark.parametrize("defer_second_b", [False, True]) @pytest.mark.parametrize("fail_first", [False, True]) async def test_messages_to_same_step_do_not_reuse_inputs_during_invocation(defer_second_b, fail_first): + from semantic_kernel.processes.kernel_process.kernel_process_step_context import KernelProcessStepContext + pairs = [] class Producer(KernelProcessStep): @@ -403,3 +377,30 @@ async def relay(self, value: int) -> int: pass assert pairs == [(1, 1), (2, 2)] + + +@pytest.fixture +def mock_process_with_steps(mock_process, mock_kernel, build_model): + """Fixture to create a LocalProcess with mock steps.""" + local_process = LocalProcess(process=mock_process, kernel=mock_kernel) + + # Create real LocalStep instances + state_1 = MagicMock(spec=KernelProcessState) + state_1.name = "step_1_state" + state_1.id = "step_1_id" + + step_info_1 = MagicMock(spec=KernelProcessStepInfo) + step_info_1.state = state_1 + + state_2 = MagicMock(spec=KernelProcessState) + state_2.name = "step_2_state" + state_2.id = "step_2_id" + + step_info_2 = MagicMock(spec=KernelProcessStepInfo) + step_info_2.state = state_2 + + step_1 = LocalStep(step_info=step_info_1, kernel=mock_kernel, parent_process_id="test_process") + step_2 = LocalStep(step_info=step_info_2, kernel=mock_kernel, parent_process_id="test_process") + + local_process.steps = [step_1, step_2] + return local_process