grasp_agents 0.2.10__py3-none-any.whl → 0.3.1__py3-none-any.whl

grasp_agents/__init__.py

@@ -1,38 +1,39 @@
 # pyright: reportUnusedImport=false
 
 
-from .agent_message import AgentMessage
-from .base_agent import BaseAgent
-from .comm_agent import CommunicatingAgent
+from .comm_processor import CommProcessor
 from .llm import LLM, LLMSettings
 from .llm_agent import LLMAgent
-from .run_context import RunArgs, RunContextWrapper
+from .llm_agent_memory import LLMAgentMemory
+from .memory import Memory
+from .packet import Packet
+from .processor import Processor
+from .run_context import RunArgs, RunContext
 from .typing.completion import Completion
 from .typing.content import Content, ImageData
-from .typing.io import AgentID, AgentState, LLMFormattedArgs, LLMPrompt, LLMPromptArgs
-from .typing.message import AssistantMessage, Conversation, SystemMessage, UserMessage
+from .typing.io import LLMPrompt, LLMPromptArgs, ProcName
+from .typing.message import AssistantMessage, Messages, SystemMessage, UserMessage
 from .typing.tool import BaseTool
 
 __all__ = [
     "LLM",
-    "AgentID",
-    "AgentMessage",
-    "AgentState",
     "AssistantMessage",
-    "BaseAgent",
     "BaseTool",
-    "CommunicatingAgent",
+    "CommProcessor",
     "Completion",
     "Content",
-    "Conversation",
     "ImageData",
     "LLMAgent",
-    "LLMFormattedArgs",
     "LLMPrompt",
     "LLMPromptArgs",
     "LLMSettings",
+    "Messages",
+    "Packet",
+    "Packet",
+    "ProcName",
+    "Processor",
     "RunArgs",
-    "RunContextWrapper",
+    "RunContext",
     "SystemMessage",
     "UserMessage",
 ]

grasp_agents/cloud_llm.py

@@ -17,16 +17,14 @@ from tenacity import (
 from typing_extensions import TypedDict
 
 from .http_client import AsyncHTTPClientParams, create_async_http_client
-from .llm import LLM, ConvertT, LLMSettings, SettingsT
-from .memory import MessageHistory
-from .rate_limiting.rate_limiter_chunked import (  # type: ignore
-    RateLimiterC,
-    limit_rate_chunked,
-)
-from .typing.completion import Completion, CompletionChunk
-from .typing.message import AssistantMessage, Conversation
+from .llm import LLM, ConvertT_co, LLMSettings, SettingsT_co
+from .message_history import MessageHistory
+from .rate_limiting.rate_limiter_chunked import RateLimiterC, limit_rate_chunked
+from .typing.completion import Completion
+from .typing.completion_chunk import CompletionChunk, combine_completion_chunks
+from .typing.events import CompletionChunkEvent, CompletionEvent
+from .typing.message import AssistantMessage, Messages
 from .typing.tool import BaseTool, ToolChoice
-from .utils import validate_obj_from_json_or_py_string
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +36,7 @@ class APIProviderInfo(TypedDict):
     name: APIProvider
     base_url: str
     api_key: str | None
-    struct_output_support: tuple[str, ...]
+    struct_outputs_support: tuple[str, ...]
 
 
 PROVIDERS: dict[APIProvider, APIProviderInfo] = {
@@ -46,19 +44,19 @@ PROVIDERS: dict[APIProvider, APIProviderInfo] = {
         name="openai",
         base_url="https://api.openai.com/v1",
         api_key=os.getenv("OPENAI_API_KEY"),
-        struct_output_support=("*",),
+        struct_outputs_support=("*",),
     ),
     "openrouter": APIProviderInfo(
         name="openrouter",
         base_url="https://openrouter.ai/api/v1",
         api_key=os.getenv("OPENROUTER_API_KEY"),
-        struct_output_support=(),
+        struct_outputs_support=(),
     ),
     "google_ai_studio": APIProviderInfo(
         name="google_ai_studio",
         base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
         api_key=os.getenv("GOOGLE_AI_STUDIO_API_KEY"),
-        struct_output_support=("*",),
+        struct_outputs_support=("*",),
     ),
 }
 
@@ -88,20 +86,16 @@ def retry_before_callback(retry_state: RetryCallState) -> None:
 
 
 class CloudLLMSettings(LLMSettings, total=False):
-    max_completion_tokens: int | None
-    temperature: float | None
-    top_p: float | None
-    seed: int | None
-    use_structured_outputs: bool
+    use_struct_outputs: bool
 
 
-class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
+class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co]):
     def __init__(
         self,
         # Base LLM args
         model_name: str,
-        converters: ConvertT,
-        llm_settings: SettingsT | None = None,
+        converters: ConvertT_co,
+        llm_settings: SettingsT_co | None = None,
         model_id: str | None = None,
         tools: list[BaseTool[BaseModel, Any, Any]] | None = None,
         response_format: type | Mapping[str, type] | None = None,
@@ -110,7 +104,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
             dict[str, Any] | AsyncHTTPClientParams | None
         ) = None,
         # Rate limiting
-        rate_limiter: (RateLimiterC[Conversation, AssistantMessage] | None) = None,
+        rate_limiter: (RateLimiterC[Messages, AssistantMessage] | None) = None,
         rate_limiter_rpm: float | None = None,
         rate_limiter_chunk_size: int = 1000,
         rate_limiter_max_concurrency: int = 300,
@@ -144,24 +138,26 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         self._api_provider: APIProvider = api_provider
         self._api_model_name: str = api_model_name
 
-        self._struct_output_support: bool = any(
+        self._struct_outputs_support: bool = any(
             fnmatch.fnmatch(self._model_name, pat)
-            for pat in PROVIDERS[api_provider]["struct_output_support"]
+            for pat in PROVIDERS[api_provider]["struct_outputs_support"]
         )
         if (
-            self._llm_settings.get("use_structured_outputs")
-            and not self._struct_output_support
+            self._llm_settings.get("use_struct_outputs")
+            and not self._struct_outputs_support
         ):
             raise ValueError(
                 f"Model {self._model_name} does not support structured outputs."
             )
 
-        self._rate_limiter: RateLimiterC[Conversation, AssistantMessage] | None = (
+        self._tool_call_settings: dict[str, Any] = {}
+
+        self._rate_limiter: RateLimiterC[Messages, AssistantMessage] | None = (
             self._get_rate_limiter(
                 rate_limiter=rate_limiter,
-                rate_limiter_rpm=rate_limiter_rpm,
-                rate_limiter_chunk_size=rate_limiter_chunk_size,
-                rate_limiter_max_concurrency=rate_limiter_max_concurrency,
+                rpm=rate_limiter_rpm,
+                chunk_size=rate_limiter_chunk_size,
+                max_concurrency=rate_limiter_max_concurrency,
             )
         )
         self.no_tqdm = no_tqdm
@@ -188,29 +184,36 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
     @property
     def rate_limiter(
         self,
-    ) -> RateLimiterC[Conversation, AssistantMessage] | None:
+    ) -> RateLimiterC[Messages, AssistantMessage] | None:
         return self._rate_limiter
 
     def _make_completion_kwargs(
-        self, conversation: Conversation, tool_choice: ToolChoice | None = None
+        self,
+        conversation: Messages,
+        tool_choice: ToolChoice | None = None,
+        n_choices: int | None = None,
     ) -> dict[str, Any]:
         api_messages = [self._converters.to_message(m) for m in conversation]
 
         api_tools = None
         api_tool_choice = None
         if self.tools:
-            api_tools = [self._converters.to_tool(t) for t in self.tools.values()]
+            api_tools = [
+                self._converters.to_tool(t, **self._tool_call_settings)
+                for t in self.tools.values()
+            ]
             if tool_choice is not None:
                 api_tool_choice = self._converters.to_tool_choice(tool_choice)
 
         api_llm_settings = deepcopy(self.llm_settings or {})
-        api_llm_settings.pop("use_structured_outputs", None)
+        api_llm_settings.pop("use_struct_outputs", None)
 
         return dict(
             api_messages=api_messages,
             api_tools=api_tools,
             api_tool_choice=api_tool_choice,
             api_response_format=self._response_format,
+            n_choices=n_choices,
             **api_llm_settings,
         )
 
@@ -221,6 +224,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         *,
         api_tools: list[Any] | None = None,
         api_tool_choice: Any | None = None,
+        n_choices: int | None = None,
         **api_llm_settings: Any,
     ) -> Any:
         pass
@@ -233,6 +237,7 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         api_tools: list[Any] | None = None,
         api_tool_choice: Any | None = None,
         api_response_format: type | None = None,
+        n_choices: int | None = None,
         **api_llm_settings: Any,
     ) -> Any:
         pass
@@ -244,161 +249,143 @@ class CloudLLM(LLM[SettingsT, ConvertT], Generic[SettingsT, ConvertT]):
         *,
         api_tools: list[Any] | None = None,
         api_tool_choice: Any | None = None,
+        n_choices: int | None = None,
         **api_llm_settings: Any,
     ) -> AsyncIterator[Any]:
         pass
 
-    async def generate_completion(
+    @abstractmethod
+    async def _get_parsed_completion_stream(
+        self,
+        api_messages: list[Any],
+        *,
+        api_tools: list[Any] | None = None,
+        api_tool_choice: Any | None = None,
+        api_response_format: type | None = None,
+        n_choices: int | None = None,
+        **api_llm_settings: Any,
+    ) -> AsyncIterator[Any]:
+        pass
+
+    async def generate_completion_no_retry(
         self,
-        conversation: Conversation,
+        conversation: Messages,
         *,
         tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
+        n_choices: int | None = None,
     ) -> Completion:
         completion_kwargs = self._make_completion_kwargs(
-            conversation=conversation, tool_choice=tool_choice
+            conversation=conversation, tool_choice=tool_choice, n_choices=n_choices
         )
 
-        if (
-            self._response_format is None
-            or (not self._struct_output_support)
-            or (not self._llm_settings.get("use_structured_outputs"))
-        ):
+        if not self._llm_settings.get("use_struct_outputs"):
             completion_kwargs.pop("api_response_format", None)
-            api_completion = await self._get_completion(**completion_kwargs, **kwargs)
+            api_completion = await self._get_completion(**completion_kwargs)
         else:
-            api_completion = await self._get_parsed_completion(
-                **completion_kwargs, **kwargs
-            )
+            api_completion = await self._get_parsed_completion(**completion_kwargs)
 
         completion = self._converters.from_completion(
-            api_completion, model_id=self.model_id
+            api_completion, name=self.model_id
         )
 
-        self._validate_completion(completion)
+        if not self._llm_settings.get("use_struct_outputs"):
+            # If validation is not handled by the structured output functionality
+            # of the LLM provider
+            self._validate_completion(completion)
+            self._validate_tool_calls(completion)
 
         return completion
 
-    def _validate_completion(self, completion: Completion) -> None:
-        for choice in completion.choices:
-            message = choice.message
-            if (
-                self._response_format_pyd is not None
-                and not self._llm_settings.get("use_structured_outputs")
-                and not message.tool_calls
-            ):
-                validate_obj_from_json_or_py_string(
-                    message.content or "",
-                    adapter=self._response_format_pyd,
-                    from_substring=True,
-                )
-
     async def generate_completion_stream(
         self,
-        conversation: Conversation,
+        conversation: Messages,
         *,
         tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
-    ) -> AsyncIterator[CompletionChunk]:
+        n_choices: int | None = None,
+    ) -> AsyncIterator[CompletionChunkEvent | CompletionEvent]:
         completion_kwargs = self._make_completion_kwargs(
-            conversation=conversation, tool_choice=tool_choice
-        )
-        completion_kwargs.pop("api_response_format", None)
-        api_completion_chunk_iterator = await self._get_completion_stream(
-            **completion_kwargs, **kwargs
+            conversation=conversation, tool_choice=tool_choice, n_choices=n_choices
         )
 
-        return self._converters.from_completion_chunk_iterator(
-            api_completion_chunk_iterator, model_id=self.model_id
-        )
+        if not self._llm_settings.get("use_struct_outputs"):
+            completion_kwargs.pop("api_response_format", None)
+            api_stream = await self._get_completion_stream(**completion_kwargs)
+        else:
+            api_stream = await self._get_parsed_completion_stream(**completion_kwargs)
+
+        async def iterate() -> AsyncIterator[CompletionChunkEvent | CompletionEvent]:
+            completion_chunks: list[CompletionChunk] = []
+            async for api_completion_chunk in api_stream:
+                completion_chunk = self._converters.from_completion_chunk(
+                    api_completion_chunk, name=self.model_id
+                )
+                completion_chunks.append(completion_chunk)
+                yield CompletionChunkEvent(data=completion_chunk, name=self.model_id)
+
+            # TODO: can be done using the OpenAI final_completion_chunk
+            completion = combine_completion_chunks(completion_chunks)
+
+            yield CompletionEvent(data=completion, name=self.model_id)
 
-    async def _generate_completion_with_retry(
+            if not self._llm_settings.get("use_struct_outputs"):
+                # If validation is not handled by the structured outputs functionality
+                # of the LLM provider
+                self._validate_completion(completion)
+                self._validate_tool_calls(completion)
+
+        return iterate()
+
+    async def generate_completion(
         self,
-        conversation: Conversation,
+        conversation: Messages,
         *,
         tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
+        n_choices: int | None = None,
     ) -> Completion:
         wrapped_func = retry(
             wait=wait_random_exponential(min=1, max=8),
             stop=stop_after_attempt(self.num_generation_retries + 1),
             before=retry_before_callback,
             retry_error_callback=retry_error_callback,
-        )(self.__class__.generate_completion)
+        )(self.__class__.generate_completion_no_retry)
 
-        return await wrapped_func(self, conversation, tool_choice=tool_choice, **kwargs)
+        return await wrapped_func(
+            self, conversation, tool_choice=tool_choice, n_choices=n_choices
+        )
 
     @limit_rate_chunked  # type: ignore
-    async def _generate_completion_batch_with_retry_and_rate_lim(
+    async def _generate_completion_batch(
         self,
-        conversation: Conversation,
+        conversation: Messages,
         *,
         tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
     ) -> Completion:
-        return await self._generate_completion_with_retry(
-            conversation, tool_choice=tool_choice, **kwargs
-        )
+        return await self.generate_completion(conversation, tool_choice=tool_choice)
 
     async def generate_completion_batch(
-        self,
-        message_history: MessageHistory,
-        *,
-        tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
+        self, message_history: MessageHistory, *, tool_choice: ToolChoice | None = None
     ) -> Sequence[Completion]:
-        return await self._generate_completion_batch_with_retry_and_rate_lim(
-            list(message_history.batched_conversations),  # type: ignore
+        return await self._generate_completion_batch(
+            list(message_history.conversations),  # type: ignore
             tool_choice=tool_choice,
-            **kwargs,
-        )
-
-    async def generate_message(
-        self,
-        conversation: Conversation,
-        *,
-        tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
-    ) -> AssistantMessage:
-        completion = await self.generate_completion(
-            conversation, tool_choice=tool_choice, **kwargs
         )
 
-        return completion.choices[0].message
-
-    async def generate_message_batch(
-        self,
-        message_history: MessageHistory,
-        *,
-        tool_choice: ToolChoice | None = None,
-        **kwargs: Any,
-    ) -> Sequence[AssistantMessage]:
-        completion_batch = await self.generate_completion_batch(
-            message_history, tool_choice=tool_choice, **kwargs
-        )
-
-        return [completion.choices[0].message for completion in completion_batch]
-
     def _get_rate_limiter(
         self,
-        rate_limiter: RateLimiterC[Conversation, AssistantMessage] | None = None,
-        rate_limiter_rpm: float | None = None,
-        rate_limiter_chunk_size: int = 1000,
-        rate_limiter_max_concurrency: int = 300,
-    ) -> RateLimiterC[Conversation, AssistantMessage] | None:
+        rate_limiter: RateLimiterC[Messages, AssistantMessage] | None = None,
+        rpm: float | None = None,
+        chunk_size: int = 1000,
+        max_concurrency: int = 300,
+    ) -> RateLimiterC[Messages, AssistantMessage] | None:
         if rate_limiter is not None:
             logger.info(
                 f"[{self.__class__.__name__}] Set rate limit to {rate_limiter.rpm} RPM"
             )
             return rate_limiter
-        if rate_limiter_rpm is not None:
-            logger.info(
-                f"[{self.__class__.__name__}] Set rate limit to {rate_limiter_rpm} RPM"
-            )
+        if rpm is not None:
+            logger.info(f"[{self.__class__.__name__}] Set rate limit to {rpm} RPM")
             return RateLimiterC(
-                rpm=rate_limiter_rpm,
-                chunk_size=rate_limiter_chunk_size,
-                max_concurrency=rate_limiter_max_concurrency,
+                rpm=rpm, chunk_size=chunk_size, max_concurrency=max_concurrency
             )
 
         return None

grasp_agents/comm_processor.py

@@ -0,0 +1,201 @@
+import logging
+from collections.abc import AsyncIterator, Sequence
+from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast
+
+from pydantic import BaseModel
+from pydantic.json_schema import SkipJsonSchema
+
+from .packet import Packet
+from .packet_pool import PacketPool
+from .processor import Processor
+from .run_context import CtxT, RunContext
+from .typing.events import Event, PacketEvent
+from .typing.io import InT_contra, MemT_co, OutT_co, ProcName
+
+logger = logging.getLogger(__name__)
+
+
+class DynCommPayload(BaseModel):
+    selected_recipients: SkipJsonSchema[Sequence[ProcName]]
+
+
+_OutT_contra = TypeVar("_OutT_contra", contravariant=True)
+
+
+class ExitCommunicationHandler(Protocol[_OutT_contra, CtxT]):
+    def __call__(
+        self,
+        out_packet: Packet[_OutT_contra],
+        ctx: RunContext[CtxT] | None,
+    ) -> bool: ...
+
+
+class CommProcessor(
+    Processor[InT_contra, OutT_co, MemT_co, CtxT],
+    Generic[InT_contra, OutT_co, MemT_co, CtxT],
+):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
+    def __init__(
+        self,
+        name: ProcName,
+        *,
+        recipients: Sequence[ProcName] | None = None,
+        packet_pool: PacketPool[CtxT] | None = None,
+    ) -> None:
+        super().__init__(name=name)
+
+        self.recipients = recipients or []
+
+        self._packet_pool = packet_pool
+        self._is_listening = False
+        self._exit_communication_impl: (
+            ExitCommunicationHandler[OutT_co, CtxT] | None
+        ) = None
+
+    def _validate_routing(self, payloads: Sequence[OutT_co]) -> Sequence[ProcName]:
+        if all(isinstance(p, DynCommPayload) for p in payloads):
+            payloads_ = cast("Sequence[DynCommPayload]", payloads)
+            selected_recipients_per_payload = [
+                set(p.selected_recipients or []) for p in payloads_
+            ]
+            assert all(
+                x == selected_recipients_per_payload[0]
+                for x in selected_recipients_per_payload
+            ), "All payloads must have the same recipient IDs for dynamic routing"
+
+            assert payloads_[0].selected_recipients is not None
+            selected_recipients = payloads_[0].selected_recipients
+
+            assert all(rid in self.recipients for rid in selected_recipients), (
+                "Dynamic routing is enabled, but recipient IDs are not in "
+                "the allowed agent's recipient IDs"
+            )
+
+            return selected_recipients
+
+        if all((not isinstance(p, DynCommPayload)) for p in payloads):
+            return self.recipients
+
+        raise ValueError(
+            "All payloads must be either DCommAgentPayload or not DCommAgentPayload"
+        )
+
+    async def run(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT_contra] | None = None,
+        in_args: InT_contra | Sequence[InT_contra] | None = None,
+        forgetful: bool = True,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> Packet[OutT_co]:
+        out_packet = await super().run(
+            chat_inputs=chat_inputs,
+            in_packet=in_packet,
+            in_args=in_args,
+            ctx=ctx,
+        )
+        recipients = self._validate_routing(out_packet.payloads)
+        routed_out_packet = Packet(
+            payloads=out_packet.payloads, sender=self.name, recipients=recipients
+        )
+        if self._packet_pool is not None and in_packet is None and in_args is None:
+            # If no input packet or args, we assume this is the first run.
+            await self._packet_pool.post(routed_out_packet)
+
+        return routed_out_packet
+
+    async def run_stream(
+        self,
+        chat_inputs: Any | None = None,
+        *,
+        in_packet: Packet[InT_contra] | None = None,
+        in_args: InT_contra | Sequence[InT_contra] | None = None,
+        forgetful: bool = True,
+        ctx: RunContext[CtxT] | None = None,
+    ) -> AsyncIterator[Event[Any]]:
+        out_packet: Packet[OutT_co] | None = None
+        async for event in super().run_stream(
+            chat_inputs=chat_inputs,
+            in_packet=in_packet,
+            in_args=in_args,
+            ctx=ctx,
+        ):
+            if isinstance(event, PacketEvent):
+                out_packet = event.data
+            else:
+                yield event
+
+        if out_packet is None:
+            raise RuntimeError("No output packet generated during stream run")
+
+        recipients = self._validate_routing(out_packet.payloads)
+        routed_out_packet = Packet(
+            payloads=out_packet.payloads, sender=self.name, recipients=recipients
+        )
+        if self._packet_pool is not None and in_packet is None and in_args is None:
+            # If no input packet or args, we assume this is the first run.
+            await self._packet_pool.post(routed_out_packet)
+
+        yield PacketEvent(data=routed_out_packet, name=self.name)
+
+    def exit_communication(
+        self, func: ExitCommunicationHandler[OutT_co, CtxT]
+    ) -> ExitCommunicationHandler[OutT_co, CtxT]:
+        self._exit_communication_impl = func
+
+        return func
+
+    def _exit_communication_fn(
+        self, out_packet: Packet[OutT_co], ctx: RunContext[CtxT] | None
+    ) -> bool:
+        if self._exit_communication_impl:
+            return self._exit_communication_impl(out_packet=out_packet, ctx=ctx)
+
+        return False
+
+    async def _packet_handler(
+        self,
+        packet: Packet[InT_contra],
+        ctx: RunContext[CtxT] | None = None,
+        **run_kwargs: Any,
+    ) -> None:
+        assert self._packet_pool is not None, "Packet pool must be initialized"
+
+        out_packet = await self.run(ctx=ctx, in_packet=packet, **run_kwargs)
+
+        if self._exit_communication_fn(out_packet=out_packet, ctx=ctx):
+            await self._packet_pool.stop_all()
+            return
+
+        await self._packet_pool.post(out_packet)
+
+    @property
+    def is_listening(self) -> bool:
+        return self._is_listening
+
+    async def start_listening(
+        self, ctx: RunContext[CtxT] | None = None, **run_kwargs: Any
+    ) -> None:
+        assert self._packet_pool is not None, "Packet pool must be initialized"
+
+        if self._is_listening:
+            return
+
+        self._is_listening = True
+        self._packet_pool.register_packet_handler(
+            processor_name=self.name,
+            handler=self._packet_handler,
+            ctx=ctx,
+            **run_kwargs,
+        )
+
+    async def stop_listening(self) -> None:
+        assert self._packet_pool is not None, "Packet pool must be initialized"
+
+        self._is_listening = False
+        await self._packet_pool.unregister_packet_handler(self.name)