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

grasp_agents/workflow/workflow_processor.py

@@ -4,23 +4,23 @@ from typing import Any, Generic
 
 from ..errors import WorkflowConstructionError
 from ..packet import Packet
-from ..processor import Processor
+from ..processors.base_processor import BaseProcessor, RecipientSelector
 from ..run_context import CtxT, RunContext
-from ..typing.events import Event
+from ..typing.events import DummyEvent, Event
 from ..typing.io import InT, OutT, ProcName
 
 
 class WorkflowProcessor(
-    Processor[InT, OutT, Any, CtxT],
+    BaseProcessor[InT, OutT, Any, CtxT],
     ABC,
     Generic[InT, OutT, CtxT],
 ):
     def __init__(
         self,
         name: ProcName,
-        subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
-        start_proc: Processor[InT, Any, Any, CtxT],
-        end_proc: Processor[Any, OutT, Any, CtxT],
+        subprocs: Sequence[BaseProcessor[Any, Any, Any, CtxT]],
+        start_proc: BaseProcessor[InT, Any, Any, CtxT],
+        end_proc: BaseProcessor[Any, OutT, Any, CtxT],
         recipients: list[ProcName] | None = None,
         max_retries: int = 0,
     ) -> None:
@@ -44,20 +44,41 @@ class WorkflowProcessor(
         self._start_proc = start_proc
         self._end_proc = end_proc
 
+        self.recipients = recipients
+        if hasattr(type(self), "recipient_selector"):
+            self._end_proc.recipient_selector = self.recipient_selector
+
+    def add_recipient_selector(
+        self, func: RecipientSelector[OutT, CtxT]
+    ) -> RecipientSelector[OutT, CtxT]:
+        self._end_proc.recipient_selector = func
+        self.recipient_selector = func
+
+        return func
+
     @property
-    def subprocs(self) -> Sequence[Processor[Any, Any, Any, CtxT]]:
+    def recipients(self) -> list[ProcName] | None:
+        return self._end_proc.recipients
+
+    @recipients.setter
+    def recipients(self, value: list[ProcName] | None) -> None:
+        if hasattr(self, "_end_proc"):
+            self._end_proc.recipients = value
+
+    @property
+    def subprocs(self) -> Sequence[BaseProcessor[Any, Any, Any, CtxT]]:
         return self._subprocs
 
     @property
-    def start_proc(self) -> Processor[InT, Any, Any, CtxT]:
+    def start_proc(self) -> BaseProcessor[InT, Any, Any, CtxT]:
         return self._start_proc
 
     @property
-    def end_proc(self) -> Processor[Any, OutT, Any, CtxT]:
+    def end_proc(self) -> BaseProcessor[Any, OutT, Any, CtxT]:
         return self._end_proc
 
     def _generate_subproc_call_id(
-        self, call_id: str | None, subproc: Processor[Any, Any, Any, CtxT]
+        self, call_id: str | None, subproc: BaseProcessor[Any, Any, Any, CtxT]
     ) -> str | None:
         return f"{self._generate_call_id(call_id)}/{subproc.name}"
 
@@ -85,4 +106,4 @@ class WorkflowProcessor(
         forgetful: bool = False,
         call_id: str | None = None,
     ) -> AsyncIterator[Event[Any]]:
-        pass
+        yield DummyEvent()

{grasp_agents-0.5.4.dist-info → grasp_agents-0.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.5.4
+Version: 0.5.6
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4

{grasp_agents-0.5.4.dist-info → grasp_agents-0.5.6.dist-info}/RECORD

@@ -1,22 +1,21 @@
-grasp_agents/__init__.py,sha256=NfnMiLttHb5iudzeDoLAK-wHCK0QBo0guPcupM99ISU,896
+grasp_agents/__init__.py,sha256=Z3a_j2Etiap9H6lvE8-PQP_OIGMUcHNPeJAJO12B8kY,1031
 grasp_agents/cloud_llm.py,sha256=C6xrKYhiQb4tNXK_rFo2pNlVTXPS_gYd5uevAnpLFeE,13119
 grasp_agents/costs_dict.yaml,sha256=2MFNWtkv5W5WSCcv1Cj13B1iQLVv5Ot9pS_KW2Gu2DA,2510
 grasp_agents/errors.py,sha256=K-22TCM1Klhsej47Rg5eTqnGiGPaXgKOpdOZZ7cPipw,4633
 grasp_agents/generics_utils.py,sha256=5Pw3I9dlnKC2VGqYKC4ZZUO3Z_vTNT-NPFovNfPkl6I,6542
 grasp_agents/grasp_logging.py,sha256=H1GYhXdQvVkmauFDZ-KDwvVmPQHZUUm9sRqX_ObK2xI,1111
 grasp_agents/http_client.py,sha256=Es8NXGDkp4Nem7g24-jW0KFGA9Hp_o2Cv3cOvjup-iU,859
-grasp_agents/llm.py,sha256=YCzHlb2gdWVy77DmQpcu0dyEzGp4VQa3UMRJKodCYSs,6557
-grasp_agents/llm_agent.py,sha256=oUMNe5yXt0JKHmVNGSpR1nyb5KyYDkrz9Nyn8sBxx1g,13682
-grasp_agents/llm_agent_memory.py,sha256=GZ2Z66_JC_sR10vATvR53ui62xxY4lDDtL0XvL_AQNk,1846
-grasp_agents/llm_policy_executor.py,sha256=jYJENUooaEz5u-ZkgCijcGIJhA2CFkXQH2TUz5KwgB4,16822
+grasp_agents/llm.py,sha256=ZkAeGEkpMsOY6T_zj2pL3ZWkP0mwDN_e9ArN99qZfmY,6574
+grasp_agents/llm_agent.py,sha256=hX3T2Y5qiTt5CrsahNo5t08HFCyBWEiurzYnFykJN9Y,13513
+grasp_agents/llm_agent_memory.py,sha256=gQwH3g4Ib3ciW2jrBiW13ttwax_pcPobH5RhXRmbc0E,1842
+grasp_agents/llm_policy_executor.py,sha256=glusWe4wTIh_rl3bXPbAMueJ5eDfJxPYBTzoecrHPYg,16849
 grasp_agents/memory.py,sha256=keHuNEZNSxHT9FKpMohHOCNi7UAz_oRIc91IQEuzaWE,1162
 grasp_agents/packet.py,sha256=EmE-W4ZSMVZoqClECGFe7OGqrT4FSJ8IVGICrdjtdEY,1462
-grasp_agents/packet_pool.py,sha256=A5hqEvh7XwaPJVkfbItMm5FQqxujVzXDId7HnSUqluI,4919
-grasp_agents/printer.py,sha256=RvUXPtbD6pdhGxoKZiddKlfMRH6WaSAIdoJSEkmpId8,11041
-grasp_agents/processor.py,sha256=tJTD2T1cmuQ-m_7bsVFsF7k4oZafh_f0p2uqdng2-sA,17053
-grasp_agents/prompt_builder.py,sha256=IFvwvl_YqwL_LGfmauf4Gr1DUGZWkHsKk0ZABFnR6HI,7124
-grasp_agents/run_context.py,sha256=f8PasaPDCBiR59AFTHRIp1wxIPAQSzJGvv_kglWOGlk,1098
-grasp_agents/runner.py,sha256=nZXK5OuM7QbLyzNA-rfXD0YDtdftTK5v2cCpeujhe2k,4479
+grasp_agents/packet_pool.py,sha256=i0g4O_fnpsYTU3LNjKgM4TiiiJkHA3YeZP9Y5GatM_I,5082
+grasp_agents/printer.py,sha256=wtCH75DgWAwjJntr57kK2e7dagcfliUAfefYHpiwWi0,11203
+grasp_agents/prompt_builder.py,sha256=UuQNnvjrhzd3_NVnvHlCs-NRNRMo4jsMePgZeIxmzSY,5894
+grasp_agents/run_context.py,sha256=ikakNK1khm0UBEIPETB508BL0IlOKbOUPuq0FZ-iQHQ,942
+grasp_agents/runner.py,sha256=sRuKkX8Iopxv_MdGZf22b_AsuH4FIPY28rl15RqwGEY,5005
 grasp_agents/usage_tracker.py,sha256=ZQfVUUpG0C89hyPWT_JgXnjQOxoYmumcQ9t-aCfcMo8,3561
 grasp_agents/utils.py,sha256=qKmGBwrQHw1-BgqRLuGTPKGs3J_zbrpk3nxnP1iZBiQ,6152
 grasp_agents/litellm/__init__.py,sha256=wD8RZBYokFDfbS9Cs7nO_zKb3w7RIVwEGj7g2D5CJH0,4510
@@ -33,6 +32,9 @@ grasp_agents/openai/converters.py,sha256=CXHF2GehEHLEzjL45HywZ_1qaB3N29-lbac5oBD
 grasp_agents/openai/message_converters.py,sha256=fhSN81uK51EGbLyM2-f0MvPX_UBrMy7SF3JQPo-dkXg,4686
 grasp_agents/openai/openai_llm.py,sha256=uJbbCytqpv8OCncKdzpiUdkVh3mJWgo95Y9Xetk_Ptg,10556
 grasp_agents/openai/tool_converters.py,sha256=IotZvpe3xMQcBfcjUTfAsn4LtZljj3zkU9bfpcoiqPw,1177
+grasp_agents/processors/base_processor.py,sha256=j2_QY6HUjckdxfsf7yAF0xRDp_V-DNDb7hIRMRKUyWw,10685
+grasp_agents/processors/parallel_processor.py,sha256=EoB1sqtnuv362S1MTUyn3-TUSO4M5Vpe86Q9HlBmbok,7816
+grasp_agents/processors/processor.py,sha256=v7Bf6CGVsjb43XuOtTMuev9UedMy_lBTGifzzCZwh4Q,5157
 grasp_agents/rate_limiting/__init__.py,sha256=KRgtF_E7R3YfA2cpYcFcZ7wycV0pWVJ0xRQC7YhiIEQ,158
 grasp_agents/rate_limiting/rate_limiter_chunked.py,sha256=BPgkUXvhmZhTpZs2T6uujNFuxH_kYHiISuf6_-eNhUc,5544
 grasp_agents/rate_limiting/types.py,sha256=PbnNhEAcYedQdIpPJWud8HUVcxa_xZS2RDZu4c5jr40,1003
@@ -42,15 +44,15 @@ grasp_agents/typing/completion.py,sha256=PHJ01m7WI2KYQL8w7W2ti6hMsKEZnzYGaxbNcBC
 grasp_agents/typing/completion_chunk.py,sha256=t6PvkDWQxRN5xA4efBdeou46RifMFodBmZc45Sx7qxQ,7610
 grasp_agents/typing/content.py,sha256=XFmLpNWkGhkw5JujO6UsYwhzTHkU67PfhzaXH2waLcQ,3659
 grasp_agents/typing/converters.py,sha256=kHlocHQS8QnduZOzNPbj3aRD8JpvJd53oudYqWdOxKE,2978
-grasp_agents/typing/events.py,sha256=1n6EVS8vU0RLlQHMHUjiV5i4PYLovT7RcOmpcx0ztlc,5256
-grasp_agents/typing/io.py,sha256=WmFfAVnqd4uNQygNAmlo0BX3q8focS6KLvCChmM0ep8,215
+grasp_agents/typing/events.py,sha256=UB0G2mQLmyLHYdEp1YnFi8XF2jpWeUZ4TLFnY64lK0I,5450
+grasp_agents/typing/io.py,sha256=MGEoUjAwKH1AHYglFkKNpHiielw-NFf13Epg3B4Q7Iw,139
 grasp_agents/typing/message.py,sha256=o7bN84AgrC5Fm3Wx20gqL9ArAMcEtYvnHnXbb04ngCs,3224
 grasp_agents/typing/tool.py,sha256=4N-k_GvHVPAFyVyEq7z_LYKkA24iQlGoVYiWCzGTgT4,1786
 grasp_agents/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-grasp_agents/workflow/looped_workflow.py,sha256=J-mdy1gxsMUC622j8W-_fDX3oAyKHg9TTzCXEksMS-Q,6311
-grasp_agents/workflow/sequential_workflow.py,sha256=7xBl6YtH97y6jSv6eAHtSIeKjoqiUWKu63C-gKp6Eus,3295
-grasp_agents/workflow/workflow_processor.py,sha256=56XC6KDRQuRftwhWnALmPUlQWCGfuTPRgIznyV2-tOg,2776
-grasp_agents-0.5.4.dist-info/METADATA,sha256=ePDw81wa-FDQu1jj46FN4tO4yUkgCt7lvn_0mDcwaDA,6865
-grasp_agents-0.5.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-grasp_agents-0.5.4.dist-info/licenses/LICENSE.md,sha256=-nNNdWqGB8gJ2O-peFQ2Irshv5tW5pHKyTcYkwvH7CE,1201
-grasp_agents-0.5.4.dist-info/RECORD,,
+grasp_agents/workflow/looped_workflow.py,sha256=WHp9O3Za2sBVfY_BLOdvPvtY20XsjZQaWSO2-oAFvOY,6806
+grasp_agents/workflow/sequential_workflow.py,sha256=e3BIWzy_2novmEWNwIteyMbrzvl1-evHrTBE3r3SpU8,3648
+grasp_agents/workflow/workflow_processor.py,sha256=yrxqAGfznmdkbP5zScKKJguxATfU4ObmA6BDR7YCBNU,3549
+grasp_agents-0.5.6.dist-info/METADATA,sha256=c0CNKc5v1lF7iPtHiLfanUt0UKQUztGVJsMcq-vco_0,6865
+grasp_agents-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+grasp_agents-0.5.6.dist-info/licenses/LICENSE.md,sha256=-nNNdWqGB8gJ2O-peFQ2Irshv5tW5pHKyTcYkwvH7CE,1201
+grasp_agents-0.5.6.dist-info/RECORD,,

grasp_agents/processor.py

@@ -1,512 +0,0 @@
-import asyncio
-import logging
-from abc import ABC
-from collections.abc import AsyncIterator, Sequence
-from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast, final
-from uuid import uuid4
-
-from pydantic import BaseModel, TypeAdapter
-from pydantic import ValidationError as PydanticValidationError
-
-from .errors import (
-    PacketRoutingError,
-    ProcInputValidationError,
-    ProcOutputValidationError,
-    ProcRunError,
-)
-from .generics_utils import AutoInstanceAttributesMixin
-from .memory import DummyMemory, MemT
-from .packet import Packet
-from .run_context import CtxT, RunContext
-from .typing.events import (
-    Event,
-    ProcPacketOutputEvent,
-    ProcPayloadOutputEvent,
-    ProcStreamingErrorData,
-    ProcStreamingErrorEvent,
-)
-from .typing.io import InT, OutT, ProcName
-from .typing.tool import BaseTool
-from .utils import stream_concurrent
-
-logger = logging.getLogger(__name__)
-
-_OutT_contra = TypeVar("_OutT_contra", contravariant=True)
-
-
-class SelectRecipientsHandler(Protocol[_OutT_contra, CtxT]):
-    def __call__(
-        self, output: _OutT_contra, ctx: RunContext[CtxT] | None
-    ) -> list[ProcName] | None: ...
-
-
-class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]):
-    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
-        0: "_in_type",
-        1: "_out_type",
-    }
-
-    def __init__(
-        self,
-        name: ProcName,
-        max_retries: int = 0,
-        recipients: list[ProcName] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        self._in_type: type[InT]
-        self._out_type: type[OutT]
-
-        super().__init__()
-
-        self._name: ProcName = name
-        self._memory: MemT = cast("MemT", DummyMemory())
-        self._max_retries: int = max_retries
-        self.recipients = recipients
-        self.select_recipients_impl: SelectRecipientsHandler[OutT, CtxT] | None = None
-
-    @property
-    def in_type(self) -> type[InT]:
-        return self._in_type
-
-    @property
-    def out_type(self) -> type[OutT]:
-        return self._out_type
-
-    @property
-    def name(self) -> ProcName:
-        return self._name
-
-    @property
-    def memory(self) -> MemT:
-        return self._memory
-
-    @property
-    def max_retries(self) -> int:
-        return self._max_retries
-
-    def _generate_call_id(self, call_id: str | None) -> str:
-        if call_id is None:
-            return str(uuid4())[:6] + "_" + self.name
-        return call_id
-
-    def _validate_inputs(
-        self,
-        call_id: str,
-        chat_inputs: Any | None = None,
-        in_packet: Packet[InT] | None = None,
-        in_args: InT | Sequence[InT] | None = None,
-    ) -> Sequence[InT] | None:
-        mult_inputs_err_message = (
-            "Only one of chat_inputs, in_args, or in_message must be provided."
-        )
-        err_kwargs = {"proc_name": self.name, "call_id": call_id}
-
-        if chat_inputs is not None and in_args is not None:
-            raise ProcInputValidationError(
-                message=mult_inputs_err_message, **err_kwargs
-            )
-        if chat_inputs is not None and in_packet is not None:
-            raise ProcInputValidationError(
-                message=mult_inputs_err_message, **err_kwargs
-            )
-        if in_args is not None and in_packet is not None:
-            raise ProcInputValidationError(
-                message=mult_inputs_err_message, **err_kwargs
-            )
-
-        if in_packet is not None and not in_packet.payloads:
-            raise ProcInputValidationError(
-                message="in_packet must contain at least one payload.", **err_kwargs
-            )
-        if in_args is not None and not in_args:
-            raise ProcInputValidationError(
-                message="in_args must contain at least one argument.", **err_kwargs
-            )
-
-        if chat_inputs is not None:
-            return None
-
-        resolved_args: Sequence[InT]
-
-        if isinstance(in_args, Sequence):
-            _in_args = cast("Sequence[Any]", in_args)
-            if all(isinstance(x, self.in_type) for x in _in_args):
-                resolved_args = cast("Sequence[InT]", _in_args)
-            elif isinstance(_in_args, self.in_type):
-                resolved_args = cast("Sequence[InT]", [_in_args])
-            else:
-                raise ProcInputValidationError(
-                    message=f"in_args are neither of type {self.in_type} "
-                    f"nor a sequence of {self.in_type}.",
-                    **err_kwargs,
-                )
-
-        elif in_args is not None:
-            resolved_args = cast("Sequence[InT]", [in_args])
-
-        else:
-            assert in_packet is not None
-            resolved_args = in_packet.payloads
-
-        try:
-            for args in resolved_args:
-                TypeAdapter(self._in_type).validate_python(args)
-        except PydanticValidationError as err:
-            raise ProcInputValidationError(message=str(err), **err_kwargs) from err
-
-        return resolved_args
-
-    def _validate_output(self, out_payload: OutT, call_id: str) -> OutT:
-        if out_payload is None:
-            return out_payload
-        try:
-            return TypeAdapter(self._out_type).validate_python(out_payload)
-        except PydanticValidationError as err:
-            raise ProcOutputValidationError(
-                schema=self._out_type, proc_name=self.name, call_id=call_id
-            ) from err
-
-    def _validate_recipients(
-        self, recipients: Sequence[ProcName] | None, call_id: str
-    ) -> None:
-        for r in recipients or []:
-            if r not in (self.recipients or []):
-                raise PacketRoutingError(
-                    proc_name=self.name,
-                    call_id=call_id,
-                    selected_recipient=r,
-                    allowed_recipients=cast("list[str]", self.recipients),
-                )
-
-    def _validate_par_recipients(
-        self, out_packets: Sequence[Packet[OutT]], call_id: str
-    ) -> None:
-        recipient_sets = [set(p.recipients or []) for p in out_packets]
-        same_recipients = all(rs == recipient_sets[0] for rs in recipient_sets)
-        if not same_recipients:
-            raise PacketRoutingError(
-                proc_name=self.name,
-                call_id=call_id,
-                message="Parallel runs must return the same recipients "
-                f"[proc_name={self.name}; call_id={call_id}]",
-            )
-
-    async def _process(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_args: InT | None = None,
-        memory: MemT,
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> OutT:
-        return cast("OutT", in_args)
-
-    async def _process_stream(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_args: InT | None = None,
-        memory: MemT,
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> AsyncIterator[Event[Any]]:
-        output = cast("OutT", in_args)
-        yield ProcPayloadOutputEvent(data=output, proc_name=self.name, call_id=call_id)
-
-    async def _run_single_once(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_args: InT | None = None,
-        forgetful: bool = False,
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> Packet[OutT]:
-        _memory = self.memory.model_copy(deep=True) if forgetful else self.memory
-
-        output = await self._process(
-            chat_inputs=chat_inputs,
-            in_args=in_args,
-            memory=_memory,
-            call_id=call_id,
-            ctx=ctx,
-        )
-        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)
-
-        return Packet(payloads=[val_output], sender=self.name, recipients=recipients)
-
-    async def _run_single(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_args: InT | None = None,
-        forgetful: bool = False,
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> Packet[OutT]:
-        n_attempt = 0
-        while n_attempt <= self.max_retries:
-            try:
-                return await self._run_single_once(
-                    chat_inputs=chat_inputs,
-                    in_args=in_args,
-                    forgetful=forgetful,
-                    call_id=call_id,
-                    ctx=ctx,
-                )
-            except Exception as err:
-                err_message = (
-                    f"\nProcessor run failed [proc_name={self.name}; call_id={call_id}]"
-                )
-                n_attempt += 1
-                if n_attempt > self.max_retries:
-                    if n_attempt == 1:
-                        logger.warning(f"{err_message}:\n{err}")
-                    if n_attempt > 1:
-                        logger.warning(f"{err_message} after retrying:\n{err}")
-                    raise ProcRunError(proc_name=self.name, call_id=call_id) from err
-
-                logger.warning(f"{err_message} (retry attempt {n_attempt}):\n{err}")
-
-        raise ProcRunError(proc_name=self.name, call_id=call_id)
-
-    async def _run_par(
-        self, in_args: Sequence[InT], call_id: str, ctx: RunContext[CtxT] | None = None
-    ) -> Packet[OutT]:
-        tasks = [
-            self._run_single(
-                in_args=inp, forgetful=True, call_id=f"{call_id}/{idx}", ctx=ctx
-            )
-            for idx, inp in enumerate(in_args)
-        ]
-        out_packets = await asyncio.gather(*tasks)
-
-        self._validate_par_recipients(out_packets, call_id=call_id)
-
-        return Packet(
-            payloads=[out_packet.payloads[0] for out_packet in out_packets],
-            sender=self.name,
-            recipients=out_packets[0].recipients,
-        )
-
-    async def run(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_packet: Packet[InT] | None = None,
-        in_args: InT | Sequence[InT] | None = None,
-        forgetful: bool = False,
-        call_id: str | None = None,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> Packet[OutT]:
-        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,
-        )
-
-        if val_in_args and len(val_in_args) > 1:
-            return await self._run_par(in_args=val_in_args, call_id=call_id, ctx=ctx)
-        return await self._run_single(
-            chat_inputs=chat_inputs,
-            in_args=val_in_args[0] if val_in_args else None,
-            forgetful=forgetful,
-            call_id=call_id,
-            ctx=ctx,
-        )
-
-    async def _run_single_stream_once(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_args: InT | None = None,
-        forgetful: bool = False,
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> AsyncIterator[Event[Any]]:
-        _memory = self.memory.model_copy(deep=True) if forgetful else self.memory
-
-        output: OutT | None = None
-        async for event in self._process_stream(
-            chat_inputs=chat_inputs,
-            in_args=in_args,
-            memory=_memory,
-            call_id=call_id,
-            ctx=ctx,
-        ):
-            if isinstance(event, ProcPayloadOutputEvent):
-                output = event.data
-            yield event
-
-        assert output is not None
-
-        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)
-
-        out_packet = Packet[OutT](
-            payloads=[val_output], sender=self.name, recipients=recipients
-        )
-
-        yield ProcPacketOutputEvent(
-            data=out_packet, proc_name=self.name, call_id=call_id
-        )
-
-    async def _run_single_stream(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_args: InT | None = None,
-        forgetful: bool = False,
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> AsyncIterator[Event[Any]]:
-        n_attempt = 0
-        while n_attempt <= self.max_retries:
-            try:
-                async for event in self._run_single_stream_once(
-                    chat_inputs=chat_inputs,
-                    in_args=in_args,
-                    forgetful=forgetful,
-                    call_id=call_id,
-                    ctx=ctx,
-                ):
-                    yield event
-
-                return
-
-            except Exception as err:
-                err_data = ProcStreamingErrorData(error=err, call_id=call_id)
-                yield ProcStreamingErrorEvent(
-                    data=err_data, proc_name=self.name, call_id=call_id
-                )
-
-                err_message = (
-                    "\nStreaming processor run failed "
-                    f"[proc_name={self.name}; call_id={call_id}]"
-                )
-
-                n_attempt += 1
-                if n_attempt > self.max_retries:
-                    if n_attempt == 1:
-                        logger.warning(f"{err_message}:\n{err}")
-                    if n_attempt > 1:
-                        logger.warning(f"{err_message} after retrying:\n{err}")
-                    raise ProcRunError(proc_name=self.name, call_id=call_id) from err
-
-                logger.warning(f"{err_message} (retry attempt {n_attempt}):\n{err}")
-
-    async def _run_par_stream(
-        self,
-        in_args: Sequence[InT],
-        call_id: str,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> AsyncIterator[Event[Any]]:
-        streams = [
-            self._run_single_stream(
-                in_args=inp, forgetful=True, call_id=f"{call_id}/{idx}", ctx=ctx
-            )
-            for idx, inp in enumerate(in_args)
-        ]
-
-        out_packets_map: dict[int, Packet[OutT]] = {}
-        async for idx, event in stream_concurrent(streams):
-            if isinstance(event, ProcPacketOutputEvent):
-                out_packets_map[idx] = event.data
-            else:
-                yield event
-
-        out_packet = Packet(
-            payloads=[
-                out_packet.payloads[0]
-                for _, out_packet in sorted(out_packets_map.items())
-            ],
-            sender=self.name,
-            recipients=out_packets_map[0].recipients,
-        )
-
-        yield ProcPacketOutputEvent(
-            data=out_packet, proc_name=self.name, call_id=call_id
-        )
-
-    async def run_stream(
-        self,
-        chat_inputs: Any | None = None,
-        *,
-        in_packet: Packet[InT] | None = None,
-        in_args: InT | Sequence[InT] | None = None,
-        forgetful: bool = False,
-        call_id: str | None = None,
-        ctx: RunContext[CtxT] | None = None,
-    ) -> AsyncIterator[Event[Any]]:
-        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,
-        )
-
-        if val_in_args and len(val_in_args) > 1:
-            stream = self._run_par_stream(in_args=val_in_args, call_id=call_id, ctx=ctx)
-        else:
-            stream = self._run_single_stream(
-                chat_inputs=chat_inputs,
-                in_args=val_in_args[0] if val_in_args else None,
-                forgetful=forgetful,
-                call_id=call_id,
-                ctx=ctx,
-            )
-        async for event in stream:
-            yield event
-
-    def _select_recipients(
-        self, output: OutT, ctx: RunContext[CtxT] | None = None
-    ) -> list[ProcName] | None:
-        if self.select_recipients_impl:
-            return self.select_recipients_impl(output=output, ctx=ctx)
-
-        return self.recipients
-
-    def select_recipients(
-        self, func: SelectRecipientsHandler[OutT, CtxT]
-    ) -> SelectRecipientsHandler[OutT, CtxT]:
-        self.select_recipients_impl = func
-
-        return func
-
-    @final
-    def as_tool(
-        self, tool_name: str, tool_description: str
-    ) -> BaseTool[InT, OutT, Any]:  # type: ignore[override]
-        # TODO: stream tools
-        processor_instance = self
-        in_type = processor_instance.in_type
-        out_type = processor_instance.out_type
-        if not issubclass(in_type, BaseModel):
-            raise TypeError(
-                "Cannot create a tool from an agent with "
-                f"non-BaseModel input type: {in_type}"
-            )
-
-        class ProcessorTool(BaseTool[in_type, out_type, Any]):
-            name: str = tool_name
-            description: str = tool_description
-
-            async def run(self, inp: InT, ctx: RunContext[CtxT] | None = None) -> OutT:
-                result = await processor_instance.run(
-                    in_args=in_type.model_validate(inp), forgetful=True, ctx=ctx
-                )
-
-                return result.payloads[0]
-
-        return ProcessorTool()