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

grasp_agents/workflow/looped_workflow.py

@@ -0,0 +1,132 @@
+from collections.abc import Sequence
+from itertools import pairwise
+from logging import getLogger
+from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast, final
+
+from ..packet_pool import Packet, PacketPool
+from ..processor import Processor
+from ..run_context import CtxT, RunContext
+from ..typing.io import InT_contra, OutT_co, ProcName
+from .workflow_processor import WorkflowProcessor
+
+logger = getLogger(__name__)
+
+_OutT_contra = TypeVar("_OutT_contra", contravariant=True)
+
+
+class ExitWorkflowLoopHandler(Protocol[_OutT_contra, CtxT]):
+    def __call__(
+        self,
+        out_packet: Packet[_OutT_contra],
+        ctx: RunContext[CtxT] | None,
+        **kwargs: Any,
+    ) -> bool: ...
+
+
+class LoopedWorkflow(
+    WorkflowProcessor[InT_contra, OutT_co, CtxT], Generic[InT_contra, OutT_co, CtxT]
+):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
+    def __init__(
+        self,
+        name: ProcName,
+        subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
+        exit_proc: Processor[Any, OutT_co, Any, CtxT],
+        packet_pool: PacketPool[CtxT] | None = None,
+        recipients: list[ProcName] | None = None,
+        max_iterations: int = 10,
+    ) -> None:
+        super().__init__(
+            subprocs=subprocs,
+            name=name,
+            start_proc=subprocs[0],
+            end_proc=exit_proc,
+            packet_pool=packet_pool,
+            recipients=recipients,
+        )
+
+        for prev_proc, proc in pairwise(subprocs):
+            if prev_proc.out_type != proc.in_type:
+                raise ValueError(
+                    f"Output type {prev_proc.out_type} of subprocessor "
+                    f"{prev_proc.name} does not match input type {proc.in_type} of "
+                    f"subprocessor {proc.name}"
+                )
+        if subprocs[-1].out_type != subprocs[0].in_type:
+            raise ValueError(
+                "Looped workflow's last subprocessor output type "
+                f"{subprocs[-1].out_type} does not match first subprocessor input "
+                f"type {subprocs[0].in_type}"
+            )
+
+        self._max_iterations = max_iterations
+
+        self._exit_workflow_loop_impl: ExitWorkflowLoopHandler[OutT_co, CtxT] | None = (
+            None
+        )
+
+    @property
+    def max_iterations(self) -> int:
+        return self._max_iterations
+
+    def exit_workflow_loop(
+        self, func: ExitWorkflowLoopHandler[OutT_co, CtxT]
+    ) -> ExitWorkflowLoopHandler[OutT_co, CtxT]:
+        self._exit_workflow_loop_impl = func
+
+        return func
+
+    def _exit_workflow_loop_fn(
+        self,
+        out_packet: Packet[OutT_co],
+        *,
+        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)
+
+        return False
+
+    @final
+    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,
+        ctx: RunContext[CtxT] | None = None,
+        forgetful: bool = False,
+    ) -> Packet[OutT_co]:
+        packet = in_packet
+        num_iterations = 0
+        exit_packet: Packet[OutT_co] | None = None
+
+        while True:
+            for subproc in self.subprocs:
+                packet = await subproc.run(
+                    chat_inputs=chat_inputs,
+                    in_packet=packet,
+                    in_args=in_args,
+                    forgetful=forgetful,
+                    ctx=ctx,
+                )
+
+                if subproc is self._end_proc:
+                    num_iterations += 1
+                    exit_packet = cast("Packet[OutT_co]", packet)
+                    if self._exit_workflow_loop_fn(exit_packet, ctx=ctx):
+                        return exit_packet
+                    if num_iterations >= self._max_iterations:
+                        logger.info(
+                            f"Max iterations reached ({self._max_iterations}). "
+                            "Exiting loop."
+                        )
+                        return exit_packet
+
+                chat_inputs = None
+                in_args = None

grasp_agents/workflow/parallel_processor.py

@@ -0,0 +1,95 @@
+import asyncio
+from collections.abc import Sequence
+from copy import deepcopy
+from typing import Any, Generic, cast
+
+from ..comm_processor import CommProcessor
+from ..packet import Packet
+from ..packet_pool import PacketPool
+from ..processor import Processor
+from ..run_context import CtxT
+from ..typing.io import InT_contra, OutT_co, ProcName
+
+
+class ParallelCommProcessor(
+    CommProcessor[InT_contra, OutT_co, Any, CtxT],
+    Generic[InT_contra, OutT_co, CtxT],
+):
+    def __init__(
+        self,
+        name: ProcName,
+        processor_type: type[Processor[InT_contra, OutT_co, Any, CtxT]],
+        packet_pool: PacketPool[CtxT] | None = None,
+        recipients: Sequence[ProcName] | None = None,
+        **subproc_init_kwargs: Any,
+    ) -> None:
+        self._processor_type = processor_type
+        self._subproc_init_kwargs = deepcopy(subproc_init_kwargs)
+
+        # NOTE: If the processor is an LLMAgent, the parallel subprocessors will share
+        # the same LLM and tools instances. Make sure their state is managed correctly.
+
+        super().__init__(name=name, packet_pool=packet_pool, recipients=recipients)
+
+    @property
+    def processor_type(self) -> type[Processor[InT_contra, OutT_co, Any, CtxT]]:
+        return self._processor_type
+
+    async def _run_subprocessor(
+        self, in_args: InT_contra, name_suffix: str, **subproc_run_kwargs: Any
+    ) -> Packet[OutT_co]:
+        subproc_name = f"{self.name}_{name_suffix}"
+        subproc = self._processor_type(name=subproc_name, **self._subproc_init_kwargs)
+
+        return await subproc.run(in_args=in_args, **subproc_run_kwargs)
+
+    def _validate_par_inputs(
+        self,
+        chat_inputs: Any | None,
+        in_packet: Packet[InT_contra] | None,
+        in_args: InT_contra | Sequence[InT_contra] | None,
+    ) -> Sequence[InT_contra]:
+        if chat_inputs is not None:
+            raise ValueError(
+                "chat_inputs are not supported in ParallelCommProcessor. "
+                "Use in_packet or in_args."
+            )
+        if in_packet is not None:
+            if not in_packet.payloads:
+                raise ValueError(
+                    "ParallelCommProcessor requires at least one input payload in "
+                    "in_packet."
+                )
+            return in_packet.payloads
+        if in_args is not None:
+            if not isinstance(in_args, Sequence) or not in_args:
+                raise ValueError("in_args must be a non-empty sequence of input data.")
+            return cast("Sequence[InT_contra]", in_args)
+        raise ValueError(
+            "ParallelCommProcessor requires either in_packet or in_args to be provided."
+        )
+
+    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,
+        **subproc_run_kwargs: Any,
+    ) -> Packet[OutT_co]:
+        par_inputs = self._validate_par_inputs(
+            chat_inputs=chat_inputs, in_packet=in_packet, in_args=in_args
+        )
+        tasks = [
+            self._run_subprocessor(
+                in_args=inp, name_suffix=str(n), **subproc_run_kwargs
+            )
+            for n, inp in enumerate(par_inputs)
+        ]
+        out_packets = await asyncio.gather(*tasks)
+
+        return Packet(
+            payloads=[out_packet.payloads[0] for out_packet in out_packets],
+            sender=self.name,
+            recipients=(self.recipients or []),
+        )

grasp_agents/workflow/sequential_workflow.py

@@ -0,0 +1,66 @@
+from collections.abc import Sequence
+from itertools import pairwise
+from typing import Any, ClassVar, Generic, cast, final
+
+from ..packet_pool import Packet, PacketPool
+from ..processor import Processor
+from ..run_context import CtxT, RunContext
+from ..typing.io import InT_contra, OutT_co, ProcName
+from .workflow_processor import WorkflowProcessor
+
+
+class SequentialWorkflow(
+    WorkflowProcessor[InT_contra, OutT_co, CtxT], Generic[InT_contra, OutT_co, CtxT]
+):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
+    def __init__(
+        self,
+        name: ProcName,
+        subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
+        packet_pool: PacketPool[CtxT] | None = None,
+        recipients: list[ProcName] | None = None,
+    ) -> None:
+        super().__init__(
+            subprocs=subprocs,
+            start_proc=subprocs[0],
+            end_proc=subprocs[-1],
+            name=name,
+            packet_pool=packet_pool,
+            recipients=recipients,
+        )
+
+        for prev_proc, proc in pairwise(subprocs):
+            if prev_proc.out_type != proc.in_type:
+                raise ValueError(
+                    f"Output type {prev_proc.out_type} of subprocessor {prev_proc.name}"
+                    f" does not match input type {proc.in_type} of subprocessor"
+                    f" {proc.name}"
+                )
+
+    @final
+    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,
+        ctx: RunContext[CtxT] | None = None,
+        forgetful: bool = False,
+    ) -> Packet[OutT_co]:
+        packet = in_packet
+        for subproc in self.subprocs:
+            packet = await subproc.run(
+                chat_inputs=chat_inputs,
+                in_packet=packet,
+                in_args=in_args,
+                forgetful=forgetful,
+                ctx=ctx,
+            )
+            chat_inputs = None
+            in_args = None
+
+        return cast("Packet[OutT_co]", packet)

grasp_agents/workflow/workflow_processor.py

@@ -0,0 +1,78 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import Any, ClassVar, Generic
+
+from ..comm_processor import CommProcessor
+from ..packet import Packet
+from ..packet_pool import PacketPool
+from ..processor import Processor
+from ..run_context import CtxT, RunContext
+from ..typing.io import InT_contra, OutT_co, ProcName
+
+
+class WorkflowProcessor(
+    CommProcessor[InT_contra, OutT_co, Any, CtxT],
+    ABC,
+    Generic[InT_contra, OutT_co, CtxT],
+):
+    _generic_arg_to_instance_attr_map: ClassVar[dict[int, str]] = {
+        0: "_in_type",
+        1: "_out_type",
+    }
+
+    def __init__(
+        self,
+        name: ProcName,
+        subprocs: Sequence[Processor[Any, Any, Any, CtxT]],
+        start_proc: Processor[InT_contra, Any, Any, CtxT],
+        end_proc: Processor[Any, OutT_co, Any, CtxT],
+        packet_pool: PacketPool[CtxT] | None = None,
+        recipients: list[ProcName] | None = None,
+    ) -> None:
+        super().__init__(name=name, packet_pool=packet_pool, recipients=recipients)
+
+        if len(subprocs) < 2:
+            raise ValueError("At least two subprocessors are required")
+        if start_proc not in subprocs:
+            raise ValueError("Start subprocessor must be in the subprocessors list")
+        if end_proc not in subprocs:
+            raise ValueError("End subprocessor must be in the subprocessors list")
+
+        if start_proc.in_type != self.in_type:
+            raise ValueError(
+                f"Start subprocessor's input type {start_proc.in_type} does not "
+                f"match workflow's input type {self._in_type}"
+            )
+        if end_proc.out_type != self.out_type:
+            raise ValueError(
+                f"End subprocessor's output type {end_proc.out_type} does not "
+                f"match workflow's output type {self._out_type}"
+            )
+
+        self._subprocs = subprocs
+        self._start_proc = start_proc
+        self._end_proc = end_proc
+
+    @property
+    def subprocs(self) -> Sequence[Processor[Any, Any, Any, CtxT]]:
+        return self._subprocs
+
+    @property
+    def start_proc(self) -> Processor[InT_contra, Any, Any, CtxT]:
+        return self._start_proc
+
+    @property
+    def end_proc(self) -> Processor[Any, OutT_co, Any, CtxT]:
+        return self._end_proc
+
+    @abstractmethod
+    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,
+        ctx: RunContext[CtxT] | None = None,
+        forgetful: bool = False,
+    ) -> Packet[OutT_co]:
+        pass

{grasp_agents-0.2.10.dist-info → grasp_agents-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.2.10
+Version: 0.3.1
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4
@@ -38,7 +38,7 @@ Description-Content-Type: text/markdown
 
 - Clean formulation of agents as generic entities over:
   - I/O schemas
-  - Agent state
+  - Memory
   - Shared context
 - Transparent implementation of common agentic patterns:
   - Single-agent loops with an optional "ReAct mode" to enforce reasoning between the tool calls
@@ -50,16 +50,15 @@ Description-Content-Type: text/markdown
 
 ## Project Structure
 
-- `base_agent.py`, `llm_agent.py`, `comm_agent.py`: Core agent class implementations.
-- `agent_message.py`, `agent_message_pool.py`: Messaging and message pool management.
-- `llm_agent_state.py`: State management for LLM agents.
-- `tool_orchestrator.py`: Orchestration of tools used by agents.
+- `processor.py`, `comm_processor.py`, `llm_agent.py`: Core processor and agent class implementations.
+- `packet.py`, `packet_pool.py`: Communication management.
+- `llm_policy_executor.py`: LLM actions and tool call loops.
 - `prompt_builder.py`: Tools for constructing prompts.
-- `workflow/`: Modules for defining and managing agent workflows.
-- `cloud_llm.py`, `llm.py`: LLM integration and base LLM functionalities.
+- `workflow/`: Modules for defining and managing static agent workflows.
+- `llm.py`, `cloud_llm.py`: LLM integration and base LLM functionalities.
 - `openai/`: Modules specific to OpenAI API integration.
-- `memory.py`: Memory management for agents (currently only message history).
-- `run_context.py`: Context management for agent runs.
+- `memory.py`, `llm_agent_memory.py`: Memory management.
+- `run_context.py`: Shared context management for agent runs.
 - `usage_tracker.py`: Tracking of API usage and costs.
 - `costs_dict.yaml`: Dictionary for cost tracking (update if needed).
 - `rate_limiting/`: Basic rate limiting tools.
@@ -111,7 +110,6 @@ Create a script, e.g., `problem_recommender.py`:
 
 ```python
 import asyncio
-import re
 from pathlib import Path
 from typing import Any
 
@@ -119,11 +117,8 @@ from dotenv import load_dotenv
 from pydantic import BaseModel, Field
 
 from grasp_agents.grasp_logging import setup_logging
-from grasp_agents.llm_agent import LLMAgent
-from grasp_agents.openai.openai_llm import OpenAILLM, OpenAILLMSettings
-from grasp_agents.run_context import RunContextWrapper
-from grasp_agents.typing.message import Conversation
-from grasp_agents.typing.tool import BaseTool
+from grasp_agents.openai import OpenAILLM, OpenAILLMSettings
+from grasp_agents import LLMAgent, BaseTool, RunContext
 
 load_dotenv()
 
@@ -135,70 +130,66 @@ setup_logging(
 )
 
 sys_prompt_react = """
-Your task is to suggest an exciting stats problem to a student.
-Ask the student about their education, interests, and preferences, then suggest a problem tailored to them.
+Your task is to suggest an exciting stats problem to the student. 
+You should first ask the student about their education, interests, and preferences, then suggest a problem tailored specifically to them. 
 
 # Instructions
+* Use the provided tool to ask questions.
 * Ask questions one by one.
 * Provide your thinking before asking a question and after receiving a reply.
-* The problem must be enclosed in <PROBLEM> tags.
+* Do not include your exact question as part of your thinking.
+* The problem must have all the necessary data.
 """
 
-
+# Tool input must be a Pydantic model to infer the JSON schema used by the LLM APIs
 class TeacherQuestion(BaseModel):
-    question: str = Field(..., description="The question to ask the student.")
+    question: str
 
 
 StudentReply = str
 
 
+ask_student_tool_description = """
+"Ask the student a question and get their reply."
+
+Args:
+    question: str
+        The question to ask the student.
+Returns:
+    reply: str
+        The student's reply to the question.
+"""
+
+
 class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, Any]):
-    name: str = "ask_student_tool"
-    description: str = "Ask the student a question and get their reply."
+    name: str = "ask_student"
+    description: str = ask_student_tool_description
 
     async def run(
-        self, inp: TeacherQuestion, ctx: RunContextWrapper[Any] | None = None
+        self, inp: TeacherQuestion, ctx: RunContext[Any] | None = None
     ) -> StudentReply:
         return input(inp.question)
 
 
-Problem = str
+class Problem(BaseModel):
+    problem: str
 
 
-teacher = LLMAgent[Any, Problem, None](
-    agent_id="teacher",
+teacher = LLMAgent[None, Problem, None](
+    name="teacher",
     llm=OpenAILLM(
         model_name="openai:gpt-4.1",
-        llm_settings=OpenAILLMSettings(temperature=0.1)
+        llm_settings=OpenAILLMSettings(temperature=0.5),
     ),
     tools=[AskStudentTool()],
-    max_turns=20,
     react_mode=True,
+    final_answer_as_tool_call=True,
     sys_prompt=sys_prompt_react,
-    set_state_strategy="reset",
 )
 
-
-@teacher.exit_tool_call_loop_handler
-def exit_tool_call_loop(
-    conversation: Conversation, ctx: RunContextWrapper[Any] | None, **kwargs: Any
-) -> bool:
-    return r"<PROBLEM>" in str(conversation[-1].content)
-
-
-@teacher.parse_output_handler
-def parse_output(
-    conversation: Conversation, ctx: RunContextWrapper[Any] | None, **kwargs: Any
-) -> Problem:
-    message = str(conversation[-1].content)
-    matches = re.findall(r"<PROBLEM>(.*?)</PROBLEM>", message, re.DOTALL)
-
-    return matches[0]
-
-
 async def main():
-    ctx = RunContextWrapper[None](print_messages=True)
-    out = await teacher.run(ctx=ctx)
+    ctx = RunContext[None](print_messages=True)
+    out = await teacher.run("start", ctx=ctx)
     print(out.payloads[0])
     print(ctx.usage_tracker.total_usage)
 

grasp_agents-0.3.1.dist-info/RECORD

@@ -0,0 +1,51 @@
+grasp_agents/__init__.py,sha256=CIsyUasb9HBC3M4olg6ATAwKXtVNmmtpyGJrt7hpZW4,947
+grasp_agents/cloud_llm.py,sha256=Psta1FH0YpBUxLnQJ55KUS5o7-eMR-uxrAP_AEUbupk,13427
+grasp_agents/comm_processor.py,sha256=YzvvHgrSrgn1oXEpkGXNrAtogFyq6gpS0UrVMBO7LBY,6722
+grasp_agents/costs_dict.yaml,sha256=2MFNWtkv5W5WSCcv1Cj13B1iQLVv5Ot9pS_KW2Gu2DA,2510
+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=KZva2MjJjuI5ohUeU8RdTAImUnQYaqBrV2jDH8smbJw,738
+grasp_agents/llm.py,sha256=5Yn4jkBPSbGVMf1sEuYXX6YrJlYZiH7oqKLY0yQIn-U,5192
+grasp_agents/llm_agent.py,sha256=Ez6_SQ3yq5X0hs7-zjqgYB0RvxoIJsaf4zzS8awrDZI,14851
+grasp_agents/llm_agent_memory.py,sha256=kD_UIF8xVgbSgW6xN87TzkdQcbTWLB-C5ZQu1_2HLx8,1770
+grasp_agents/llm_policy_executor.py,sha256=ODyxTgqtbBnTRbCanMKjcQ7ET1fYy28_f2Jh_xXxY0Y,17876
+grasp_agents/memory.py,sha256=gPkVIIF6dI_xXzarIAw9kSEnSJcfW_teUsWA2JAih94,671
+grasp_agents/message_history.py,sha256=-ZNy3C1z0yQeahjqR0oIoWDMySJ7vPS19jdutibW7OE,5408
+grasp_agents/packet.py,sha256=PZ1EpclniAoLk7z4ieZbWzgYH3JSRgnlTe_WfbJYG_4,707
+grasp_agents/packet_pool.py,sha256=9umHbi5FwuUYYhhodSR-Z-fRR6OYiZyYEzq5d4nZFK4,3036
+grasp_agents/printer.py,sha256=eVpSZMVk4ZLkV78Sgfg1euzkaS3XBCb30yJcwLMqI0w,5464
+grasp_agents/processor.py,sha256=bfkDJn_zZHLbCQzKj8DcPKpBj9leV0pvmqYuoGn-U9g,6744
+grasp_agents/prompt_builder.py,sha256=eW_TOVarvh5niZcNg6EpiUrR_xv_xKZ0QT04RnzCLxc,8454
+grasp_agents/run_context.py,sha256=0y1JDbz3hJbGiqd3EjUYagkMbEK8YlCzdErp3R2MCr0,1647
+grasp_agents/usage_tracker.py,sha256=SPwv6RpdoHRuMIKE2hCAWAvDbtR3uXuhr2jpHQuKWhI,3438
+grasp_agents/utils.py,sha256=uOUt4LDnErp3WQ2aQesH6mkMzon1-NIsft-o6aVznJE,4522
+grasp_agents/openai/__init__.py,sha256=wpTeew6EjhM6esHCKrEKUpwq0kygMN2QQDxYtmbRG8Y,4201
+grasp_agents/openai/completion_chunk_converters.py,sha256=i-1SvIWhRKtL0K8p5pb3jjACSnyHuJHTCoZovEERpxs,2628
+grasp_agents/openai/completion_converters.py,sha256=vzPEkUOX4l2hobKxZjEk_dyWfzeYesO0DlvWvNVb-Sg,2656
+grasp_agents/openai/content_converters.py,sha256=r1D5uci5x7sbDyl0XN27y-l_jVigCauJruvSdZSnZcc,2510
+grasp_agents/openai/converters.py,sha256=ncscVyPnPMMbyxAfFX3U73lnr_BZU-I89HA5Ld8BuxI,4691
+grasp_agents/openai/message_converters.py,sha256=_fG4vI42rBzoajuC5iYgnUBalg8cQ1ckSt8xFBOuWVY,4111
+grasp_agents/openai/openai_llm.py,sha256=sd1nE5eLUMA8NBqUkSwo_BTfyEBmp9j7Gpuf_s0abw4,7961
+grasp_agents/openai/tool_converters.py,sha256=d_7edJbnUhfSs2-F4J20D71UjVJWIslsXwMyac7-v2Q,1246
+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
+grasp_agents/rate_limiting/utils.py,sha256=oEDWDNHYMUdxOOG49PlAJochkZq8nnVBCo6JxPc1iSo,2007
+grasp_agents/typing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grasp_agents/typing/completion.py,sha256=KrvdFZqOcw5GePdMhDoFuwCkMJ86nqRdz9mT9s2lFv4,2445
+grasp_agents/typing/completion_chunk.py,sha256=b1d2a_8h21Uoif_FCS05XDMKap2nZWYV9G4goLKkoL0,5866
+grasp_agents/typing/content.py,sha256=VdnHdW8PHDCtX_ffvcwQz-7ypPUQNSGqHa3txFE_72Y,3676
+grasp_agents/typing/converters.py,sha256=kHlocHQS8QnduZOzNPbj3aRD8JpvJd53oudYqWdOxKE,2978
+grasp_agents/typing/events.py,sha256=QbrvXnDmXFr9_cSsdqL9f35eQLOfZ2O0h3a6yCRtKwY,2625
+grasp_agents/typing/io.py,sha256=_9G_pfEc41mHCLZ5lJ4N4qn7I-QDSOrdK8EFnQrSP18,315
+grasp_agents/typing/message.py,sha256=jTdN6-wVftfzplRjAz9zEWCpx_wPOBgcaMl0fcnsioU,2415
+grasp_agents/typing/tool.py,sha256=AfC6dsFiNAhM80yI9eh1Qm5U5WzJXsTHogXK-Zn4_cE,2495
+grasp_agents/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+grasp_agents/workflow/looped_workflow.py,sha256=QqXclXYxsW6C8Rxkf3dRaMHi-DfCvCbjvFZr4nBl1u0,4299
+grasp_agents/workflow/parallel_processor.py,sha256=Xyzs2UR_mRe2GFgzzadHOhqgMu3rFjd3GUjvmZimt_k,3505
+grasp_agents/workflow/sequential_workflow.py,sha256=Pl7jl9ZVDu-rC5UMfympEaQN8iG3kZurVF5eIPG62XA,2130
+grasp_agents/workflow/workflow_processor.py,sha256=2-iaDIlgNXgj-ClGbiE3fYfSv-N_qRC49Gf_dF6M_40,2640
+grasp_agents-0.3.1.dist-info/METADATA,sha256=Oa-Dmx94NHXOLj03LCM6kBe2EtdVcR70IaSoGKTWemg,6806
+grasp_agents-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+grasp_agents-0.3.1.dist-info/licenses/LICENSE.md,sha256=-nNNdWqGB8gJ2O-peFQ2Irshv5tW5pHKyTcYkwvH7CE,1201
+grasp_agents-0.3.1.dist-info/RECORD,,

grasp_agents/agent_message.py

@@ -1,27 +0,0 @@
-from collections.abc import Sequence
-from typing import Generic, TypeVar
-from uuid import uuid4
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from .typing.io import AgentID, AgentState
-
-_PayloadT = TypeVar("_PayloadT", covariant=True)  # noqa: PLC0105
-_StateT = TypeVar("_StateT", bound=AgentState, covariant=True)  # noqa: PLC0105
-
-
-class AgentMessage(BaseModel, Generic[_PayloadT, _StateT]):
-    payloads: Sequence[_PayloadT]
-    sender_id: AgentID
-    sender_state: _StateT | None = None
-    recipient_ids: Sequence[AgentID] = Field(default_factory=list)
-
-    message_id: str = Field(default_factory=lambda: str(uuid4())[:8])
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    def __repr__(self) -> str:
-        return (
-            f"From: {self.sender_id}, To: {', '.join(self.recipient_ids)}, "
-            f"Payloads: {len(self.payloads)}"
-        )