grasp_agents 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

grasp_agents/processors/processor.py

@@ -0,0 +1,161 @@
+import logging
+from collections.abc import AsyncIterator
+from typing import Any, ClassVar, Generic, cast
+
+from ..memory import MemT
+from ..packet import Packet
+from ..run_context import CtxT, RunContext
+from ..typing.events import Event, ProcPacketOutputEvent, ProcPayloadOutputEvent
+from ..typing.io import InT, OutT, ProcName
+from .base_processor import BaseProcessor, with_retry, with_retry_stream
+
+logger = logging.getLogger(__name__)
+
+
+class Processor(BaseProcessor[InT, OutT, MemT, CtxT], Generic[InT, OutT, MemT, CtxT]):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
+    async def _process(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_args: list[InT] | None = None,
+        memory: MemT,
+        call_id: str,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> list[OutT]:
+        return cast("list[OutT]", in_args)
+
+    async def _process_stream(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_args: list[InT] | None = None,
+        memory: MemT,
+        call_id: str,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> AsyncIterator[Event[Any]]:
+        outputs = await self._process(
+            chat_inputs=chat_inputs,
+            in_args=in_args,
+            memory=memory,
+            call_id=call_id,
+            ctx=ctx,
+        )
+        for output in outputs:
+            yield ProcPayloadOutputEvent(
+                data=output, proc_name=self.name, call_id=call_id
+            )
+
+    def _preprocess(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT] | None = None,
+        in_args: InT | list[InT] | None = None,
+        forgetful: bool = False,
+        call_id: str | None = None,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> tuple[list[InT] | None, MemT, str]:
+        call_id = self._generate_call_id(call_id)
+
+        val_in_args = self._validate_inputs(
+            call_id=call_id,
+            chat_inputs=chat_inputs,
+            in_packet=in_packet,
+            in_args=in_args,
+        )
+
+        memory = self.memory.model_copy(deep=True) if forgetful else self.memory
+
+        return val_in_args, memory, call_id
+
+    def _postprocess(
+        self, outputs: list[OutT], call_id: str, ctx: RunContext[CtxT] | None = None
+    ) -> Packet[OutT]:
+        payloads: list[OutT] = []
+        routing: dict[int, list[ProcName] | None] = {}
+        for idx, output in enumerate(outputs):
+            val_output = self._validate_output(output, call_id=call_id)
+            recipients = self._select_recipients(output=val_output, ctx=ctx)
+            self._validate_recipients(recipients, call_id=call_id)
+
+            payloads.append(val_output)
+            routing[idx] = recipients
+
+        recipient_sets = [set(r or []) for r in routing.values()]
+        if all(r == recipient_sets[0] for r in recipient_sets):
+            recipients = routing[0]
+        else:
+            recipients = routing
+
+        return Packet(payloads=payloads, sender=self.name, recipients=recipients)  # type: ignore[return-value]
+
+    @with_retry
+    async def run(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT] | None = None,
+        in_args: InT | list[InT] | None = None,
+        forgetful: bool = False,
+        call_id: str | None = None,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> Packet[OutT]:
+        val_in_args, memory, call_id = self._preprocess(
+            chat_inputs=chat_inputs,
+            in_packet=in_packet,
+            in_args=in_args,
+            forgetful=forgetful,
+            call_id=call_id,
+            ctx=ctx,
+        )
+        outputs = await self._process(
+            chat_inputs=chat_inputs,
+            in_args=val_in_args,
+            memory=memory,
+            call_id=call_id,
+            ctx=ctx,
+        )
+
+        return self._postprocess(outputs=outputs, call_id=call_id, ctx=ctx)
+
+    @with_retry_stream
+    async def run_stream(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT] | None = None,
+        in_args: InT | list[InT] | None = None,
+        forgetful: bool = False,
+        call_id: str | None = None,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> AsyncIterator[Event[Any]]:
+        val_in_args, memory, call_id = self._preprocess(
+            chat_inputs=chat_inputs,
+            in_packet=in_packet,
+            in_args=in_args,
+            forgetful=forgetful,
+            call_id=call_id,
+            ctx=ctx,
+        )
+        outputs: list[OutT] = []
+        async for event in self._process_stream(
+            chat_inputs=chat_inputs,
+            in_args=val_in_args,
+            memory=memory,
+            call_id=call_id,
+            ctx=ctx,
+        ):
+            if isinstance(event, ProcPayloadOutputEvent):
+                outputs.append(event.data)
+            yield event
+
+        out_packet = self._postprocess(outputs=outputs, call_id=call_id, ctx=ctx)
+
+        yield ProcPacketOutputEvent(
+            data=out_packet, proc_name=self.name, call_id=call_id
+        )

grasp_agents/prompt_builder.py

@@ -1,34 +1,26 @@
 import json
 from collections.abc import Sequence
-from typing import ClassVar, Generic, Protocol, TypeAlias, TypeVar
+from typing import ClassVar, Generic, Protocol, TypeAlias, TypeVar, final
 
 from pydantic import BaseModel, TypeAdapter
 
-from .errors import InputPromptBuilderError, SystemPromptBuilderError
+from .errors import InputPromptBuilderError
 from .generics_utils import AutoInstanceAttributesMixin
 from .run_context import CtxT, RunContext
 from .typing.content import Content, ImageData
-from .typing.io import InT, LLMPrompt, LLMPromptArgs
+from .typing.io import InT, LLMPrompt
 from .typing.message import UserMessage
 
 _InT_contra = TypeVar("_InT_contra", contravariant=True)
 
 
-class MakeSystemPromptHandler(Protocol[CtxT]):
-    def __call__(
-        self,
-        sys_args: LLMPromptArgs | None,
-        *,
-        ctx: RunContext[CtxT] | None,
-    ) -> str | None: ...
+class SystemPromptBuilder(Protocol[CtxT]):
+    def __call__(self, ctx: RunContext[CtxT] | None) -> str | None: ...
 
 
-class MakeInputContentHandler(Protocol[_InT_contra, CtxT]):
+class InputContentBuilder(Protocol[_InT_contra, CtxT]):
     def __call__(
-        self,
-        in_args: _InT_contra | None,
-        *,
-        ctx: RunContext[CtxT] | None,
+        self, in_args: _InT_contra | None, *, ctx: RunContext[CtxT] | None
     ) -> Content: ...
 
 
@@ -39,11 +31,7 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
     _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {0: "_in_type"}
 
     def __init__(
-        self,
-        agent_name: str,
-        sys_prompt: LLMPrompt | None,
-        in_prompt: LLMPrompt | None,
-        sys_args_schema: type[LLMPromptArgs] | None = None,
+        self, agent_name: str, sys_prompt: LLMPrompt | None, in_prompt: LLMPrompt | None
     ):
         self._in_type: type[InT]
         super().__init__()
@@ -51,45 +39,17 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
         self._agent_name = agent_name
         self.sys_prompt = sys_prompt
         self.in_prompt = in_prompt
-        self.sys_args_schema = sys_args_schema
-        self.make_system_prompt_impl: MakeSystemPromptHandler[CtxT] | None = None
-        self.make_input_content_impl: MakeInputContentHandler[InT, CtxT] | None = None
+        self.system_prompt_builder: SystemPromptBuilder[CtxT] | None = None
+        self.input_content_builder: InputContentBuilder[InT, CtxT] | None = None
 
         self._in_args_type_adapter: TypeAdapter[InT] = TypeAdapter(self._in_type)
 
-    def _validate_sys_args(
-        self, sys_args: LLMPromptArgs | None
-    ) -> LLMPromptArgs | None:
-        val_sys_args = sys_args
-        if sys_args is not None:
-            if self.sys_args_schema is not None:
-                val_sys_args = self.sys_args_schema.model_validate(sys_args)
-            else:
-                raise SystemPromptBuilderError(
-                    proc_name=self._agent_name,
-                    message="System prompt template and arguments is set, "
-                    "but system arguments schema is not provided "
-                    f"[agent_name={self._agent_name}]",
-                )
-
-        return val_sys_args
-
-    def make_system_prompt(
-        self,
-        sys_args: LLMPromptArgs | None = None,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> str | None:
-        if self.sys_prompt is None:
-            return None
-
-        val_sys_args = self._validate_sys_args(sys_args=sys_args)
-
-        if self.make_system_prompt_impl:
-            return self.make_system_prompt_impl(sys_args=val_sys_args, ctx=ctx)
-
-        sys_args_dict = val_sys_args.model_dump() if val_sys_args else {}
+    @final
+    def build_system_prompt(self, ctx: RunContext[CtxT] | None = None) -> str | None:
+        if self.system_prompt_builder:
+            return self.system_prompt_builder(ctx=ctx)
 
-        return self.sys_prompt.format(**sys_args_dict)
+        return self.sys_prompt
 
     def _validate_input_args(self, in_args: InT) -> InT:
         val_in_args = self._in_args_type_adapter.validate_python(in_args)
@@ -111,7 +71,8 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
 
         return val_in_args
 
-    def make_input_content(
+    @final
+    def _build_input_content(
         self,
         in_args: InT | None = None,
         ctx: RunContext[CtxT] | None = None,
@@ -120,8 +81,8 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
         if in_args is not None:
             val_in_args = self._validate_input_args(in_args=in_args)
 
-        if self.make_input_content_impl:
-            return self.make_input_content_impl(in_args=val_in_args, ctx=ctx)
+        if self.input_content_builder:
+            return self.input_content_builder(in_args=val_in_args, ctx=ctx)
 
         if val_in_args is None:
             raise InputPromptBuilderError(
@@ -141,7 +102,8 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
         ).decode("utf-8")
         return Content.from_text(fmt_in_args)
 
-    def make_input_message(
+    @final
+    def build_input_message(
         self,
         chat_inputs: LLMPrompt | Sequence[str | ImageData] | None = None,
         in_args: InT | None = None,
@@ -160,7 +122,7 @@ class PromptBuilder(AutoInstanceAttributesMixin, Generic[InT, CtxT]):
             return UserMessage.from_content_parts(chat_inputs, name=self._agent_name)
 
         return UserMessage(
-            content=self.make_input_content(in_args=in_args, ctx=ctx),
+            content=self._build_input_content(in_args=in_args, ctx=ctx),
             name=self._agent_name,
         )
 

grasp_agents/run_context.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, ConfigDict, Field
 from grasp_agents.typing.completion import Completion
 
 from .printer import ColoringMode, Printer
-from .typing.io import LLMPromptArgs, ProcName
+from .typing.io import ProcName
 from .usage_tracker import UsageTracker
 
 CtxT = TypeVar("CtxT")
@@ -15,22 +15,17 @@ CtxT = TypeVar("CtxT")
 class RunContext(BaseModel, Generic[CtxT]):
     state: CtxT | None = None
 
-    sys_args: dict[ProcName, LLMPromptArgs] = Field(default_factory=dict)
-
-    is_streaming: bool = False
-    result: Any | None = None
-
     completions: dict[ProcName, list[Completion]] = Field(
         default_factory=lambda: defaultdict(list)
     )
     usage_tracker: UsageTracker = Field(default_factory=UsageTracker)
 
     printer: Printer | None = None
-    print_messages: bool = False
+    log_messages: bool = False
     color_messages_by: ColoringMode = "role"
 
     def model_post_init(self, context: Any) -> None:  # noqa: ARG002
-        if self.print_messages:
+        if self.log_messages:
             self.printer = Printer(color_by=self.color_messages_by)
 
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)

grasp_agents/runner.py

@@ -1,3 +1,4 @@
+import logging
 from collections.abc import AsyncIterator, Sequence
 from functools import partial
 from typing import Any, Generic
@@ -5,11 +6,13 @@ from typing import Any, Generic
 from .errors import RunnerError
 from .packet import Packet, StartPacket
 from .packet_pool import END_PROC_NAME, PacketPool
-from .processor import Processor
+from .processors.processor import Processor
 from .run_context import CtxT, RunContext
 from .typing.events import Event, ProcPacketOutputEvent, RunResultEvent
 from .typing.io import OutT
 
+logger = logging.getLogger(__name__)
+
 
 class Runner(Generic[OutT, CtxT]):
     def __init__(
@@ -53,9 +56,18 @@ class Runner(Generic[OutT, CtxT]):
         **run_kwargs: Any,
     ) -> None:
         _in_packet, _chat_inputs = self._unpack_packet(packet)
+
+        logger.info(f"\n[Running processor {proc.name}]\n")
+
         out_packet = await proc.run(
             chat_inputs=_chat_inputs, in_packet=_in_packet, ctx=ctx, **run_kwargs
         )
+
+        logger.info(
+            f"\n[Finished running processor {proc.name}]\n"
+            f"Posting output packet to recipients {out_packet.recipients}\n"
+        )
+
         await pool.post(out_packet)
 
     async def _packet_handler_stream(
@@ -68,6 +80,8 @@ class Runner(Generic[OutT, CtxT]):
     ) -> None:
         _in_packet, _chat_inputs = self._unpack_packet(packet)
 
+        logger.info(f"\n[Running processor {proc.name}]\n")
+
         out_packet: Packet[Any] | None = None
         async for event in proc.run_stream(
             chat_inputs=_chat_inputs, in_packet=_in_packet, ctx=ctx, **run_kwargs
@@ -78,6 +92,11 @@ class Runner(Generic[OutT, CtxT]):
 
         assert out_packet is not None
 
+        logger.info(
+            f"\n[Finished running processor {proc.name}]\n"
+            f"Posting output packet to recipients {out_packet.recipients}\n"
+        )
+
         await pool.post(out_packet)
 
     async def run(

grasp_agents/typing/events.py

@@ -57,6 +57,10 @@ class Event(BaseModel, Generic[_T], frozen=True):
     call_id: str | None = None
     data: _T
 
+class DummyEvent(Event[Any], frozen=True):
+    type: Literal[EventType.PAYLOAD_OUT] = EventType.PAYLOAD_OUT
+    source: Literal[EventSourceType.PROC] = EventSourceType.PROC
+    data: Any = None
 
 class CompletionEvent(Event[Completion], frozen=True):
     type: Literal[EventType.COMP] = EventType.COMP

grasp_agents/typing/io.py

@@ -1,16 +1,9 @@
 from typing import TypeAlias, TypeVar
 
-from pydantic import BaseModel
-
 ProcName: TypeAlias = str
 
 
 InT = TypeVar("InT")
 OutT = TypeVar("OutT")
 
-
-class LLMPromptArgs(BaseModel):
-    pass
-
-
 LLMPrompt: TypeAlias = str

grasp_agents/workflow/looped_workflow.py

@@ -5,7 +5,7 @@ from typing import Any, Generic, Protocol, TypeVar, cast, final
 
 from ..errors import WorkflowConstructionError
 from ..packet_pool import Packet
-from ..processor import Processor
+from ..processors.base_processor import BaseProcessor
 from ..run_context import CtxT, RunContext
 from ..typing.events import Event, ProcPacketOutputEvent, WorkflowResultEvent
 from ..typing.io import InT, OutT, ProcName
@@ -16,7 +16,7 @@ logger = getLogger(__name__)
 _OutT_contra = TypeVar("_OutT_contra", contravariant=True)
 
 
-class ExitWorkflowLoopHandler(Protocol[_OutT_contra, CtxT]):
+class WorkflowLoopTerminator(Protocol[_OutT_contra, CtxT]):
     def __call__(
         self,
         out_packet: Packet[_OutT_contra],
@@ -29,8 +29,8 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
     def __init__(
         self,
         name: ProcName,
-        subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
-        exit_proc: Processor[Any, OutT, Any, CtxT],
+        subprocs: Sequence[BaseProcessor[Any, Any, Any, CtxT]],
+        exit_proc: BaseProcessor[Any, OutT, Any, CtxT],
         recipients: list[ProcName] | None = None,
         max_retries: int = 0,
         max_iterations: int = 10,
@@ -60,28 +60,30 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
 
         self._max_iterations = max_iterations
 
-        self._exit_workflow_loop_impl: ExitWorkflowLoopHandler[OutT, CtxT] | None = None
+        self.workflow_loop_terminator: WorkflowLoopTerminator[OutT, CtxT] | None
+        if not hasattr(type(self), "workflow_loop_terminator"):
+            self.workflow_loop_terminator = None
 
     @property
     def max_iterations(self) -> int:
         return self._max_iterations
 
-    def exit_workflow_loop(
-        self, func: ExitWorkflowLoopHandler[OutT, CtxT]
-    ) -> ExitWorkflowLoopHandler[OutT, CtxT]:
-        self._exit_workflow_loop_impl = func
+    def add_workflow_loop_terminator(
+        self, func: WorkflowLoopTerminator[OutT, CtxT]
+    ) -> WorkflowLoopTerminator[OutT, CtxT]:
+        self.workflow_loop_terminator = func
 
         return func
 
-    def _exit_workflow_loop(
+    def _terminate_workflow_loop(
         self,
         out_packet: Packet[OutT],
         *,
         ctx: RunContext[CtxT] | None = None,
         **kwargs: Any,
     ) -> bool:
-        if self._exit_workflow_loop_impl:
-            return self._exit_workflow_loop_impl(out_packet, ctx=ctx, **kwargs)
+        if self.workflow_loop_terminator:
+            return self.workflow_loop_terminator(out_packet, ctx=ctx, **kwargs)
 
         return False
 
@@ -96,14 +98,15 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
         forgetful: bool = False,
         ctx: RunContext[CtxT] | None = None,
     ) -> Packet[OutT]:
-        call_id = self._generate_call_id(call_id)
-
         packet = in_packet
-        num_iterations = 0
         exit_packet: Packet[OutT] | None = None
 
-        while True:
+        for num_iterations in range(1, self._max_iterations + 1):
+            call_id = self._generate_call_id(call_id)
+
             for subproc in self.subprocs:
+                logger.info(f"\n[Running subprocessor {subproc.name}]\n")
+
                 packet = await subproc.run(
                     chat_inputs=chat_inputs,
                     in_packet=packet,
@@ -113,12 +116,13 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
                     ctx=ctx,
                 )
 
+                logger.info(f"\n[Finished running subprocessor {subproc.name}]\n")
+
                 if subproc is self._end_proc:
-                    num_iterations += 1
                     exit_packet = cast("Packet[OutT]", packet)
-                    if self._exit_workflow_loop(exit_packet, ctx=ctx):
+                    if self._terminate_workflow_loop(exit_packet, ctx=ctx):
                         return exit_packet
-                    if num_iterations >= self._max_iterations:
+                    if num_iterations == self._max_iterations:
                         logger.info(
                             f"Max iterations reached ({self._max_iterations}). "
                             "Exiting loop."
@@ -128,8 +132,10 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
                 chat_inputs = None
                 in_args = None
 
+        raise RuntimeError("Looped workflow did not exit after max iterations.")
+
     @final
-    async def run_stream(  # type: ignore[override]
+    async def run_stream(
         self,
         chat_inputs: Any | None = None,
         *,
@@ -139,14 +145,15 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
         forgetful: bool = False,
         ctx: RunContext[CtxT] | None = None,
     ) -> AsyncIterator[Event[Any]]:
-        call_id = self._generate_call_id(call_id)
-
         packet = in_packet
-        num_iterations = 0
         exit_packet: Packet[OutT] | None = None
 
-        while True:
+        for num_iterations in range(1, self._max_iterations + 1):
+            call_id = self._generate_call_id(call_id)
+
             for subproc in self.subprocs:
+                logger.info(f"\n[Running subprocessor {subproc.name}]\n")
+
                 async for event in subproc.run_stream(
                     chat_inputs=chat_inputs,
                     in_packet=packet,
@@ -159,15 +166,16 @@ class LoopedWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT
                         packet = event.data
                     yield event
 
+                logger.info(f"\n[Finished running subprocessor {subproc.name}]\n")
+
                 if subproc is self._end_proc:
-                    num_iterations += 1
                     exit_packet = cast("Packet[OutT]", packet)
-                    if self._exit_workflow_loop(exit_packet, ctx=ctx):
+                    if self._terminate_workflow_loop(exit_packet, ctx=ctx):
                         yield WorkflowResultEvent(
                             data=exit_packet, proc_name=self.name, call_id=call_id
                         )
                         return
-                    if num_iterations >= self._max_iterations:
+                    if num_iterations == self._max_iterations:
                         logger.info(
                             f"Max iterations reached ({self._max_iterations}). "
                             "Exiting loop."

grasp_agents/workflow/sequential_workflow.py

@@ -1,21 +1,24 @@
+import logging
 from collections.abc import AsyncIterator, Sequence
 from itertools import pairwise
 from typing import Any, Generic, cast, final
 
 from ..errors import WorkflowConstructionError
 from ..packet_pool import Packet
-from ..processor import Processor
+from ..processors.base_processor import BaseProcessor
 from ..run_context import CtxT, RunContext
 from ..typing.events import Event, ProcPacketOutputEvent, WorkflowResultEvent
 from ..typing.io import InT, OutT, ProcName
 from .workflow_processor import WorkflowProcessor
 
+logger = logging.getLogger(__name__)
+
 
 class SequentialWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT, CtxT]):
     def __init__(
         self,
         name: ProcName,
-        subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
+        subprocs: Sequence[BaseProcessor[Any, Any, Any, CtxT]],
         recipients: list[ProcName] | None = None,
         max_retries: int = 0,
     ) -> None:
@@ -51,6 +54,8 @@ class SequentialWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT,
 
         packet = in_packet
         for subproc in self.subprocs:
+            logger.info(f"\n[Running subprocessor {subproc.name}]\n")
+
             packet = await subproc.run(
                 chat_inputs=chat_inputs,
                 in_packet=packet,
@@ -62,10 +67,12 @@ class SequentialWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT,
             chat_inputs = None
             in_args = None
 
+            logger.info(f"\n[Finished running subprocessor {subproc.name}]\n")
+
         return cast("Packet[OutT]", packet)
 
     @final
-    async def run_stream(  # type: ignore[override]
+    async def run_stream(
         self,
         chat_inputs: Any | None = None,
         *,
@@ -79,6 +86,8 @@ class SequentialWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT,
 
         packet = in_packet
         for subproc in self.subprocs:
+            logger.info(f"\n[Running subprocessor {subproc.name}]\n")
+
             async for event in subproc.run_stream(
                 chat_inputs=chat_inputs,
                 in_packet=packet,
@@ -94,6 +103,8 @@ class SequentialWorkflow(WorkflowProcessor[InT, OutT, CtxT], Generic[InT, OutT,
             chat_inputs = None
             in_args = None
 
+            logger.info(f"\n[Finished running subprocessor {subproc.name}]\n")
+
         yield WorkflowResultEvent(
             data=cast("Packet[OutT]", packet), proc_name=self.name, call_id=call_id
         )