chore: import upstream snapshot with attribution

python/semantic_kernel/processes/dapr_runtime/interfaces/event_buffer_interface.py

@@ -0,0 +1,32 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from abc import ABC, abstractmethod
+
+from dapr.actor import ActorInterface, actormethod
+
+from semantic_kernel.utils.feature_stage_decorator import experimental
+
+
+@experimental
+class EventBufferInterface(ActorInterface, ABC):
+    """Abstract base class for an event buffer that follows the ActorInterface."""
+
+    @abstractmethod
+    @actormethod(name="enqueue")
+    async def enqueue(self, step_event: str) -> None:
+        """Enqueues a `ProcessEvent` step event into the buffer.
+
+        Args:
+            step_event: The step event to enqueue.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="dequeue_all")
+    async def dequeue_all(self) -> list[str]:
+        """Dequeues a step event from the buffer.
+
+        Returns:
+            The dequeued step event as a list of `ProcessEvent`.
+        """
+        ...

python/semantic_kernel/processes/dapr_runtime/interfaces/external_event_buffer_interface.py

@@ -0,0 +1,35 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from abc import ABC, abstractmethod
+
+from dapr.actor import ActorInterface, actormethod
+
+from semantic_kernel.utils.feature_stage_decorator import experimental
+
+
+@experimental
+class ExternalEventBufferInterface(ActorInterface, ABC):
+    """Abstract base class for an external event buffer that follows the ActorInterface."""
+
+    @abstractmethod
+    @actormethod(name="enqueue")
+    async def enqueue(self, external_event: str) -> None:
+        """Enqueues an external event into the buffer.
+
+        Args:
+            external_event: The external event to enqueue.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="dequeue_all")
+    async def dequeue_all(self) -> list[str]:
+        """Dequeues all external events from the buffer as.
+
+        The list is of string representations of KernelProcessEvent.
+
+        Returns:
+            The dequeued external event.
+        """
+        ...

python/semantic_kernel/processes/dapr_runtime/interfaces/message_buffer_interface.py

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from abc import ABC, abstractmethod
+
+from dapr.actor import ActorInterface, actormethod
+
+from semantic_kernel.utils.feature_stage_decorator import experimental
+
+
+@experimental
+class MessageBufferInterface(ActorInterface, ABC):
+    """Abstract base class for a message event buffer that follows the ActorInterface."""
+
+    @abstractmethod
+    @actormethod(name="enqueue")
+    async def enqueue(self, message: str) -> None:
+        """Enqueues a message event into the buffer.
+
+        Args:
+            message: The message event to enqueue.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="dequeue_all")
+    async def dequeue_all(self) -> list[str]:
+        """Dequeues all process events from the buffer.
+
+        Returns:
+            The dequeued message event as a list of string
+            representing a ProcessEvent.
+        """
+        ...

python/semantic_kernel/processes/dapr_runtime/interfaces/process_interface.py

@@ -0,0 +1,69 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from dapr.actor import ActorInterface, actormethod
+
+from semantic_kernel.utils.feature_stage_decorator import experimental
+
+if TYPE_CHECKING:
+    from semantic_kernel.processes.kernel_process.kernel_process_event import KernelProcessEvent
+
+
+@experimental
+class ProcessInterface(ActorInterface, ABC):
+    """Abstract base class for a process that follows the ActorInterface."""
+
+    @abstractmethod
+    @actormethod(name="initialize_process")
+    async def initialize_process(self, input: dict) -> None:
+        """Initializes the process with the specified instance of DaprProcessInfo.
+
+        :param process_info: Used to initialize the process.
+        :param parent_process_id: The parent ID of the process if one exists.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="start")
+    async def start(self, keep_alive: bool) -> None:
+        """Starts an initialized process.
+
+        :param keep_alive: Indicates if the process should wait for external events after it's finished processing.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="run_once")
+    async def run_once(self, process_event: "KernelProcessEvent | str | None") -> None:
+        """Starts the process with an initial event and then waits for the process to finish.
+
+        :param process_event: Required. The KernelProcessEvent to start the process with.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="stop")
+    async def stop(self) -> None:
+        """Stops a running process, canceling and waiting for it to complete before returning."""
+        ...
+
+    @abstractmethod
+    @actormethod(name="send_message")
+    async def send_message(self, process_event: "KernelProcessEvent") -> None:
+        """Sends a message to the process without starting it if it is not already running.
+
+        :param process_event: Required. The KernelProcessEvent to queue for the process.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="get_process_info")
+    async def get_process_info(self) -> dict:
+        """Retrieves the process information as a dict of DaprProcessInfo.
+
+        :return: An instance of DaprProcessInfo.
+        """
+        ...

python/semantic_kernel/processes/dapr_runtime/interfaces/step_interface.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+
+from abc import ABC, abstractmethod
+
+from dapr.actor import ActorInterface, actormethod
+
+from semantic_kernel.utils.feature_stage_decorator import experimental
+
+
+@experimental
+class StepInterface(ActorInterface, ABC):
+    """Abstract base class for a step in the process workflow."""
+
+    @abstractmethod
+    @actormethod(name="initialize_step")
+    async def initialize_step(self, input: str) -> None:
+        """Initializes the step with the provided step information.
+
+        Args:
+            input: the DaprStepinfo and ParentProcessId dictionary as a str
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="prepare_incoming_messages")
+    async def prepare_incoming_messages(self) -> int:
+        """Triggers the step to dequeue all pending messages and prepare for processing.
+
+        Returns:
+            The number of messages that were dequeued.
+        """
+        ...
+
+    @abstractmethod
+    @actormethod(name="process_incoming_messages")
+    async def process_incoming_messages(self) -> None:
+        """Triggers the step to process all prepared messages."""
+        ...
+
+    @abstractmethod
+    @actormethod(name="to_dapr_step_info")
+    async def to_dapr_step_info(self) -> dict:
+        """Builds the current state of the step into a DaprStepInfo.
+
+        Returns:
+            The DaprStepInfo representing the current state of the step.
+        """
+        ...