grasp_agents 0.5.4__tar.gz → 0.5.5__tar.gz

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/PKG-INFO

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

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "grasp_agents"
-version = "0.5.4"
+version = "0.5.5"
 description = "Grasp Agents Library"
 readme = "README.md"
 requires-python = ">=3.11.4,<4"

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/__init__.py

@@ -10,7 +10,7 @@ from .processor import Processor
 from .run_context import RunContext
 from .typing.completion import Completion
 from .typing.content import Content, ImageData
-from .typing.io import LLMPrompt, LLMPromptArgs, ProcName
+from .typing.io import LLMPrompt, ProcName
 from .typing.message import AssistantMessage, Messages, SystemMessage, UserMessage
 from .typing.tool import BaseTool
 
@@ -24,7 +24,6 @@ __all__ = [
     "LLMAgent",
     "LLMAgentMemory",
     "LLMPrompt",
-    "LLMPromptArgs",
     "LLMSettings",
     "Memory",
     "Messages",

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/llm_agent.py

@@ -1,21 +1,21 @@
 from collections.abc import AsyncIterator, Sequence
 from pathlib import Path
-from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast
+from typing import Any, ClassVar, Generic, Protocol, TypeVar, cast, final
 
 from pydantic import BaseModel
 
 from .llm import LLM, LLMSettings
-from .llm_agent_memory import LLMAgentMemory, PrepareMemoryHandler
+from .llm_agent_memory import LLMAgentMemory, MemoryPreparator
 from .llm_policy_executor import (
-    ExitToolCallLoopHandler,
     LLMPolicyExecutor,
-    ManageMemoryHandler,
+    MemoryManager,
+    ToolCallLoopTerminator,
 )
 from .processor import Processor
 from .prompt_builder import (
-    MakeInputContentHandler,
-    MakeSystemPromptHandler,
+    InputContentBuilder,
     PromptBuilder,
+    SystemPromptBuilder,
 )
 from .run_context import CtxT, RunContext
 from .typing.content import Content, ImageData
@@ -26,7 +26,7 @@ from .typing.events import (
     SystemMessageEvent,
     UserMessageEvent,
 )
-from .typing.io import InT, LLMPrompt, LLMPromptArgs, OutT, ProcName
+from .typing.io import InT, LLMPrompt, OutT, ProcName
 from .typing.message import Message, Messages, SystemMessage, UserMessage
 from .typing.tool import BaseTool
 from .utils import get_prompt, validate_obj_from_json_or_py_string
@@ -35,7 +35,7 @@ _InT_contra = TypeVar("_InT_contra", contravariant=True)
 _OutT_co = TypeVar("_OutT_co", covariant=True)
 
 
-class ParseOutputHandler(Protocol[_InT_contra, _OutT_co, CtxT]):
+class OutputParser(Protocol[_InT_contra, _OutT_co, CtxT]):
     def __call__(
         self,
         conversation: Messages,
@@ -68,8 +68,6 @@ class LLMAgent(
         # System prompt template
         sys_prompt: LLMPrompt | None = None,
         sys_prompt_path: str | Path | None = None,
-        # System args (static args provided via RunContext)
-        sys_args_schema: type[LLMPromptArgs] | None = None,
         # Agent loop settings
         max_turns: int = 100,
         react_mode: bool = False,
@@ -88,10 +86,22 @@ class LLMAgent(
         self._memory: LLMAgentMemory = LLMAgentMemory()
         self._reset_memory_on_run = reset_memory_on_run
 
+        self.memory_preparator: MemoryPreparator | None
+        if not hasattr(type(self), "memory_preparator"):
+            self.memory_preparator = None
+
+        self.output_parser: OutputParser[InT, OutT, CtxT] | None
+        if not hasattr(type(self), "output_parser"):
+            self.output_parser = None
+
         # LLM policy executor
 
         self._used_default_llm_response_schema: bool = False
-        if llm.response_schema is None and tools is None:
+        if (
+            llm.response_schema is None
+            and tools is None
+            and not hasattr(type(self), "output_parser")
+        ):
             llm.response_schema = self.out_type
             self._used_default_llm_response_schema = True
 
@@ -119,17 +129,11 @@ class LLMAgent(
 
         sys_prompt = get_prompt(prompt_text=sys_prompt, prompt_path=sys_prompt_path)
         in_prompt = get_prompt(prompt_text=in_prompt, prompt_path=in_prompt_path)
-        self._prompt_builder: PromptBuilder[InT, CtxT] = PromptBuilder[
-            self.in_type, CtxT
-        ](
-            agent_name=self._name,
-            sys_prompt=sys_prompt,
-            in_prompt=in_prompt,
-            sys_args_schema=sys_args_schema,
+
+        self._prompt_builder = PromptBuilder[self.in_type, CtxT](
+            agent_name=self._name, sys_prompt=sys_prompt, in_prompt=in_prompt
         )
 
-        self._prepare_memory_impl: PrepareMemoryHandler | None = None
-        self._parse_output_impl: ParseOutputHandler[InT, OutT, CtxT] | None = None
         self._register_overridden_handlers()
 
     @property
@@ -144,10 +148,6 @@ class LLMAgent(
     def max_turns(self) -> int:
         return self._policy_executor.max_turns
 
-    @property
-    def sys_args_schema(self) -> type[LLMPromptArgs] | None:
-        return self._prompt_builder.sys_args_schema
-
     @property
     def sys_prompt(self) -> LLMPrompt | None:
         return self._prompt_builder.sys_prompt
@@ -156,6 +156,7 @@ class LLMAgent(
     def in_prompt(self) -> LLMPrompt | None:
         return self._prompt_builder.in_prompt
 
+    @final
     def _prepare_memory(
         self,
         memory: LLMAgentMemory,
@@ -163,8 +164,8 @@ class LLMAgent(
         sys_prompt: LLMPrompt | None = None,
         ctx: RunContext[Any] | None = None,
     ) -> None:
-        if self._prepare_memory_impl:
-            return self._prepare_memory_impl(
+        if self.memory_preparator:
+            return self.memory_preparator(
                 memory=memory, in_args=in_args, sys_prompt=sys_prompt, ctx=ctx
             )
 
@@ -175,16 +176,7 @@ class LLMAgent(
         in_args: InT | None = None,
         ctx: RunContext[CtxT] | None = None,
     ) -> tuple[SystemMessage | None, UserMessage | None]:
-        # 1. Get system arguments
-        sys_args = ctx.sys_args.get(self.name) if ctx and ctx.sys_args else None
-
-        # 2. Make system prompt (can be None)
-
-        formatted_sys_prompt = self._prompt_builder.make_system_prompt(
-            sys_args=sys_args, ctx=ctx
-        )
-
-        # 3. Set agent memory
+        formatted_sys_prompt = self._prompt_builder.build_system_prompt(ctx=ctx)
 
         system_message: SystemMessage | None = None
         if self._reset_memory_on_run or memory.is_empty:
@@ -196,9 +188,7 @@ class LLMAgent(
                 memory=memory, in_args=in_args, sys_prompt=formatted_sys_prompt, ctx=ctx
             )
 
-        # 3. Make and add input messages
-
-        input_message = self._prompt_builder.make_input_message(
+        input_message = self._prompt_builder.build_input_message(
             chat_inputs=chat_inputs, in_args=in_args, ctx=ctx
         )
         if input_message:
@@ -213,8 +203,8 @@ class LLMAgent(
         in_args: InT | None = None,
         ctx: RunContext[CtxT] | None = None,
     ) -> OutT:
-        if self._parse_output_impl:
-            return self._parse_output_impl(
+        if self.output_parser:
+            return self.output_parser(
                 conversation=conversation, in_args=in_args, ctx=ctx
             )
 
@@ -302,108 +292,100 @@ class LLMAgent(
         cur_cls = type(self)
         base_cls = LLMAgent[Any, Any, Any]
 
-        # Packet routing
-        if cur_cls._select_recipients is not base_cls._select_recipients:  # noqa: SLF001
-            self.select_recipients_impl = self._select_recipients
-
         # Prompt builder
 
-        if cur_cls._make_system_prompt is not base_cls._make_system_prompt:  # noqa: SLF001
-            self._prompt_builder.make_system_prompt_impl = self._make_system_prompt
+        if cur_cls.system_prompt_builder is not base_cls.system_prompt_builder:
+            self._prompt_builder.system_prompt_builder = self.system_prompt_builder
 
-        if cur_cls._make_input_content is not base_cls._make_input_content:  # noqa: SLF001
-            self._prompt_builder.make_input_content_impl = self._make_input_content
+        if cur_cls.input_content_builder is not base_cls.input_content_builder:
+            self._prompt_builder.input_content_builder = self.input_content_builder
 
         # Policy executor
 
-        if (
-            cur_cls._exit_tool_call_loop is not base_cls._exit_tool_call_loop  # noqa: SLF001
-        ):
-            self._policy_executor.exit_tool_call_loop_impl = self._exit_tool_call_loop
-
-        if cur_cls._manage_memory is not base_cls._manage_memory:  # noqa: SLF001
-            self._policy_executor.manage_memory_impl = self._manage_memory
+        if cur_cls.tool_call_loop_terminator is not base_cls.tool_call_loop_terminator:
+            self._policy_executor.tool_call_loop_terminator = (
+                self.tool_call_loop_terminator
+            )
 
-        # Make sure default LLM response schema is not used when custom output
-        # parsing is provided
-        if (
-            cur_cls._parse_output is not base_cls._parse_output  # noqa: SLF001
-            and self._used_default_llm_response_schema
-        ):
-            self._policy_executor.llm.response_schema = None
+        if cur_cls.memory_manager is not base_cls.memory_manager:
+            self._policy_executor.memory_manager = self.memory_manager
 
-    def _make_system_prompt(
-        self, sys_args: LLMPromptArgs | None, *, ctx: RunContext[CtxT] | None = None
-    ) -> str | None:
-        return self._prompt_builder.make_system_prompt(sys_args=sys_args, ctx=ctx)
+    def system_prompt_builder(self, ctx: RunContext[CtxT] | None = None) -> str | None:
+        if self._prompt_builder.system_prompt_builder is not None:
+            return self._prompt_builder.system_prompt_builder(ctx=ctx)
+        raise NotImplementedError("System prompt builder is not implemented.")
 
-    def _make_input_content(
+    def input_content_builder(
         self, in_args: InT | None = None, *, ctx: RunContext[CtxT] | None = None
     ) -> Content:
-        return self._prompt_builder.make_input_content(in_args=in_args, ctx=ctx)
+        if self._prompt_builder.input_content_builder is not None:
+            return self._prompt_builder.input_content_builder(in_args=in_args, ctx=ctx)
+        raise NotImplementedError("Input content builder is not implemented.")
 
-    def _exit_tool_call_loop(
+    def tool_call_loop_terminator(
         self,
         conversation: Messages,
         *,
         ctx: RunContext[CtxT] | None = None,
         **kwargs: Any,
     ) -> bool:
-        return self._policy_executor._exit_tool_call_loop(  # type: ignore[return-value]
-            conversation=conversation, ctx=ctx, **kwargs
-        )
+        if self._policy_executor.tool_call_loop_terminator is not None:
+            return self._policy_executor.tool_call_loop_terminator(
+                conversation=conversation, ctx=ctx, **kwargs
+            )
+        raise NotImplementedError("Tool call loop terminator is not implemented.")
 
-    def _manage_memory(
+    def memory_manager(
         self,
         memory: LLMAgentMemory,
         *,
         ctx: RunContext[CtxT] | None = None,
         **kwargs: Any,
     ) -> None:
-        return self._policy_executor._manage_memory(  # type: ignore[return-value]
-            memory=memory, ctx=ctx, **kwargs
-        )
+        if self._policy_executor.memory_manager is not None:
+            return self._policy_executor.memory_manager(
+                memory=memory, ctx=ctx, **kwargs
+            )
+        raise NotImplementedError("Memory manager is not implemented.")
 
     # Decorators for custom implementations as an alternative to overriding methods
 
-    def make_system_prompt(
-        self, func: MakeSystemPromptHandler[CtxT]
-    ) -> MakeSystemPromptHandler[CtxT]:
-        self._prompt_builder.make_system_prompt_impl = func
+    def add_system_prompt_builder(
+        self, func: SystemPromptBuilder[CtxT]
+    ) -> SystemPromptBuilder[CtxT]:
+        self._prompt_builder.system_prompt_builder = func
 
         return func
 
-    def make_input_content(
-        self, func: MakeInputContentHandler[InT, CtxT]
-    ) -> MakeInputContentHandler[InT, CtxT]:
-        self._prompt_builder.make_input_content_impl = func
+    def add_input_content_builder(
+        self, func: InputContentBuilder[InT, CtxT]
+    ) -> InputContentBuilder[InT, CtxT]:
+        self._prompt_builder.input_content_builder = func
 
         return func
 
-    def parse_output(
-        self, func: ParseOutputHandler[InT, OutT, CtxT]
-    ) -> ParseOutputHandler[InT, OutT, CtxT]:
-        if self._used_default_llm_response_schema:
-            self._policy_executor.llm.response_schema = None
-        self._parse_output_impl = func
+    def add_memory_manager(self, func: MemoryManager[CtxT]) -> MemoryManager[CtxT]:
+        self._policy_executor.memory_manager = func
 
         return func
 
-    def prepare_memory(self, func: PrepareMemoryHandler) -> PrepareMemoryHandler:
-        self._prepare_memory_impl = func
+    def add_tool_call_loop_terminator(
+        self, func: ToolCallLoopTerminator[CtxT]
+    ) -> ToolCallLoopTerminator[CtxT]:
+        self._policy_executor.tool_call_loop_terminator = func
 
         return func
 
-    def manage_memory(
-        self, func: ManageMemoryHandler[CtxT]
-    ) -> ManageMemoryHandler[CtxT]:
-        self._policy_executor.manage_memory_impl = func
+    def add_output_parser(
+        self, func: OutputParser[InT, OutT, CtxT]
+    ) -> OutputParser[InT, OutT, CtxT]:
+        if self._used_default_llm_response_schema:
+            self._policy_executor.llm.response_schema = None
+        self.output_parser = func
 
         return func
 
-    def exit_tool_call_loop(
-        self, func: ExitToolCallLoopHandler[CtxT]
-    ) -> ExitToolCallLoopHandler[CtxT]:
-        self._policy_executor.exit_tool_call_loop_impl = func
+    def add_memory_preparator(self, func: MemoryPreparator) -> MemoryPreparator:
+        self.memory_preparator = func
 
         return func

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/llm_agent_memory.py

@@ -9,7 +9,7 @@ from .typing.io import LLMPrompt
 from .typing.message import Message, Messages, SystemMessage
 
 
-class PrepareMemoryHandler(Protocol):
+class MemoryPreparator(Protocol):
     def __call__(
         self,
         memory: "LLMAgentMemory",

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/llm_policy_executor.py

@@ -3,7 +3,7 @@ import json
 from collections.abc import AsyncIterator, Coroutine, Sequence
 from itertools import starmap
 from logging import getLogger
-from typing import Any, Generic, Protocol
+from typing import Any, Generic, Protocol, final
 
 from pydantic import BaseModel
 
@@ -29,7 +29,7 @@ from .typing.tool import BaseTool, NamedToolChoice, ToolCall, ToolChoice
 logger = getLogger(__name__)
 
 
-class ExitToolCallLoopHandler(Protocol[CtxT]):
+class ToolCallLoopTerminator(Protocol[CtxT]):
     def __call__(
         self,
         conversation: Messages,
@@ -39,7 +39,7 @@ class ExitToolCallLoopHandler(Protocol[CtxT]):
     ) -> bool: ...
 
 
-class ManageMemoryHandler(Protocol[CtxT]):
+class MemoryManager(Protocol[CtxT]):
     def __call__(
         self,
         memory: LLMAgentMemory,
@@ -78,8 +78,8 @@ class LLMPolicyExecutor(Generic[CtxT]):
         self._max_turns = max_turns
         self._react_mode = react_mode
 
-        self.exit_tool_call_loop_impl: ExitToolCallLoopHandler[CtxT] | None = None
-        self.manage_memory_impl: ManageMemoryHandler[CtxT] | None = None
+        self.tool_call_loop_terminator: ToolCallLoopTerminator[CtxT] | None = None
+        self.memory_manager: MemoryManager[CtxT] | None = None
 
     @property
     def agent_name(self) -> str:
@@ -97,18 +97,20 @@ class LLMPolicyExecutor(Generic[CtxT]):
     def max_turns(self) -> int:
         return self._max_turns
 
-    def _exit_tool_call_loop(
+    @final
+    def _terminate_tool_call_loop(
         self,
         conversation: Messages,
         *,
         ctx: RunContext[CtxT] | None = None,
         **kwargs: Any,
     ) -> bool:
-        if self.exit_tool_call_loop_impl:
-            return self.exit_tool_call_loop_impl(conversation, ctx=ctx, **kwargs)
+        if self.tool_call_loop_terminator:
+            return self.tool_call_loop_terminator(conversation, ctx=ctx, **kwargs)
 
         return False
 
+    @final
     def _manage_memory(
         self,
         memory: LLMAgentMemory,
@@ -116,8 +118,8 @@ class LLMPolicyExecutor(Generic[CtxT]):
         ctx: RunContext[CtxT] | None = None,
         **kwargs: Any,
     ) -> None:
-        if self.manage_memory_impl:
-            self.manage_memory_impl(memory=memory, ctx=ctx, **kwargs)
+        if self.memory_manager:
+            self.memory_manager(memory=memory, ctx=ctx, **kwargs)
 
     async def generate_message(
         self,
@@ -309,8 +311,8 @@ class LLMPolicyExecutor(Generic[CtxT]):
             # 2. Check if we should exit the tool call loop
 
             # If a final answer is not provided via a tool call, we use
-            # exit_tool_call_loop to determine whether to exit the loop.
-            if not self._final_answer_as_tool_call and self._exit_tool_call_loop(
+            # _terminate_tool_call_loop to determine whether to exit the loop.
+            if not self._final_answer_as_tool_call and self._terminate_tool_call_loop(
                 memory.message_history, ctx=ctx, num_turns=turns
             ):
                 return gen_message
@@ -390,7 +392,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
         turns = 0
 
         while True:
-            if not self._final_answer_as_tool_call and self._exit_tool_call_loop(
+            if not self._final_answer_as_tool_call and self._terminate_tool_call_loop(
                 memory.message_history, ctx=ctx, num_turns=turns
             ):
                 return

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/printer.py

@@ -119,7 +119,7 @@ class Printer:
         # Thinking
         if isinstance(message, AssistantMessage) and message.reasoning_content:
             thinking = message.reasoning_content.strip(" \n")
-            out += f"\n<thinking>\n{thinking}\n</thinking>\n"
+            out += f"<thinking>\n{thinking}\n</thinking>\n"
 
         # Content
         content = self.content_to_str(message.content or "", message.role)

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/processor.py

@@ -34,7 +34,7 @@ logger = logging.getLogger(__name__)
 _OutT_contra = TypeVar("_OutT_contra", contravariant=True)
 
 
-class SelectRecipientsHandler(Protocol[_OutT_contra, CtxT]):
+class RecipientSelector(Protocol[_OutT_contra, CtxT]):
     def __call__(
         self, output: _OutT_contra, ctx: RunContext[CtxT] | None
     ) -> list[ProcName] | None: ...
@@ -61,8 +61,13 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         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
+
+        self.recipient_selector: RecipientSelector[OutT, CtxT] | None
+        if not hasattr(type(self), "recipient_selector"):
+            # Set to None if not defined in the subclass
+            self.recipient_selector = None
 
     @property
     def in_type(self) -> type[InT]:
@@ -94,8 +99,8 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         call_id: str,
         chat_inputs: Any | None = None,
         in_packet: Packet[InT] | None = None,
-        in_args: InT | Sequence[InT] | None = None,
-    ) -> Sequence[InT] | None:
+        in_args: InT | list[InT] | None = None,
+    ) -> list[InT] | None:
         mult_inputs_err_message = (
             "Only one of chat_inputs, in_args, or in_message must be provided."
         )
@@ -126,14 +131,14 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         if chat_inputs is not None:
             return None
 
-        resolved_args: Sequence[InT]
+        resolved_args: list[InT]
 
-        if isinstance(in_args, Sequence):
-            _in_args = cast("Sequence[Any]", in_args)
+        if isinstance(in_args, list):
+            _in_args = cast("list[Any]", in_args)
             if all(isinstance(x, self.in_type) for x in _in_args):
-                resolved_args = cast("Sequence[InT]", _in_args)
+                resolved_args = cast("list[InT]", _in_args)
             elif isinstance(_in_args, self.in_type):
-                resolved_args = cast("Sequence[InT]", [_in_args])
+                resolved_args = cast("list[InT]", [_in_args])
             else:
                 raise ProcInputValidationError(
                     message=f"in_args are neither of type {self.in_type} "
@@ -142,11 +147,11 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
                 )
 
         elif in_args is not None:
-            resolved_args = cast("Sequence[InT]", [in_args])
+            resolved_args = cast("list[InT]", [in_args])
 
         else:
             assert in_packet is not None
-            resolved_args = in_packet.payloads
+            resolved_args = cast("list[InT]", in_packet.payloads)
 
         try:
             for args in resolved_args:
@@ -167,7 +172,7 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
             ) from err
 
     def _validate_recipients(
-        self, recipients: Sequence[ProcName] | None, call_id: str
+        self, recipients: list[ProcName] | None, call_id: str
     ) -> None:
         for r in recipients or []:
             if r not in (self.recipients or []):
@@ -191,6 +196,22 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
                 f"[proc_name={self.name}; call_id={call_id}]",
             )
 
+    @final
+    def _select_recipients(
+        self, output: OutT, ctx: RunContext[CtxT] | None = None
+    ) -> list[ProcName] | None:
+        if self.recipient_selector:
+            return self.recipient_selector(output=output, ctx=ctx)
+
+        return self.recipients
+
+    def add_recipient_selector(
+        self, func: RecipientSelector[OutT, CtxT]
+    ) -> RecipientSelector[OutT, CtxT]:
+        self.recipient_selector = func
+
+        return func
+
     async def _process(
         self,
         chat_inputs: Any | None = None,
@@ -275,7 +296,7 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         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
+        self, in_args: list[InT], call_id: str, ctx: RunContext[CtxT] | None = None
     ) -> Packet[OutT]:
         tasks = [
             self._run_single(
@@ -298,7 +319,7 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         chat_inputs: Any | None = None,
         *,
         in_packet: Packet[InT] | None = None,
-        in_args: InT | Sequence[InT] | None = None,
+        in_args: InT | list[InT] | None = None,
         forgetful: bool = False,
         call_id: str | None = None,
         ctx: RunContext[CtxT] | None = None,
@@ -406,7 +427,7 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
 
     async def _run_par_stream(
         self,
-        in_args: Sequence[InT],
+        in_args: list[InT],
         call_id: str,
         ctx: RunContext[CtxT] | None = None,
     ) -> AsyncIterator[Event[Any]]:
@@ -442,7 +463,7 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         chat_inputs: Any | None = None,
         *,
         in_packet: Packet[InT] | None = None,
-        in_args: InT | Sequence[InT] | None = None,
+        in_args: InT | list[InT] | None = None,
         forgetful: bool = False,
         call_id: str | None = None,
         ctx: RunContext[CtxT] | None = None,
@@ -469,21 +490,6 @@ class Processor(AutoInstanceAttributesMixin, ABC, Generic[InT, OutT, MemT, CtxT]
         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

{grasp_agents-0.5.4 → grasp_agents-0.5.5}/src/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-0.5.4 → grasp_agents-0.5.5}/src/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-0.5.4 → grasp_agents-0.5.5}/src/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-0.5.4 → grasp_agents-0.5.5}/src/grasp_agents/workflow/workflow_processor.py

@@ -4,7 +4,7 @@ from typing import Any, Generic
 
 from ..errors import WorkflowConstructionError
 from ..packet import Packet
-from ..processor import Processor
+from ..processor import Processor, RecipientSelector
 from ..run_context import CtxT, RunContext
 from ..typing.events import Event
 from ..typing.io import InT, OutT, ProcName
@@ -44,6 +44,21 @@ class WorkflowProcessor(
         self._start_proc = start_proc
         self._end_proc = end_proc
 
+        self.recipients = end_proc.recipients
+        if recipients is not None:
+            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]]:
         return self._subprocs