grasp_agents 0.5.11__tar.gz → 0.5.12__tar.gz

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grasp_agents
-Version: 0.5.11
+Version: 0.5.12
 Summary: Grasp Agents Library
 License-File: LICENSE.md
 Requires-Python: <4,>=3.11.4
@@ -110,24 +110,16 @@ Create a script, e.g., `problem_recommender.py`:
 
 ```python
 import asyncio
-from pathlib import Path
 from typing import Any
 
 from dotenv import load_dotenv
 from pydantic import BaseModel, Field
 
-from grasp_agents.grasp_logging import setup_logging
+from grasp_agents import LLMAgent, BaseTool, RunContext, Printer
 from grasp_agents.litellm import LiteLLM, LiteLLMSettings
-from grasp_agents import LLMAgent, BaseTool, RunContext
-
-load_dotenv()
 
 
-# Configure the logger to output to the console and/or a file
-setup_logging(
-    logs_file_path="grasp_agents_demo.log",
-    logs_config_path=Path().cwd() / "configs/logging/default.yaml",
-)
+load_dotenv()
 
 sys_prompt_react = """
 Your task is to suggest an exciting stats problem to the student. 
@@ -162,7 +154,7 @@ Returns:
 """
 
 
-class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, Any]):
+class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, None]):
     name: str = "ask_student"
     description: str = ask_student_tool_description
 
@@ -176,11 +168,7 @@ class Problem(BaseModel):
 
 teacher = LLMAgent[None, Problem, None](
     name="teacher",
-    llm=LiteLLM(
-        model_name="gpt-4.1",
-        # model_name="claude-sonnet-4-20250514",
-        # llm_settings=LiteLLMSettings(reasoning_effort="low"),
-    ),
+    llm=LiteLLM(model_name="gpt-4.1"),
     tools=[AskStudentTool()],
     react_mode=True,
     final_answer_as_tool_call=True,
@@ -188,7 +176,7 @@ teacher = LLMAgent[None, Problem, None](
 )
 
 async def main():
-    ctx = RunContext[None](log_messages=True)
+    ctx = RunContext[None](printer=Printer())
     out = await teacher.run("start", ctx=ctx)
     print(out.payloads[0])
     print(ctx.usage_tracker.total_usage)

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/README.md

@@ -93,24 +93,16 @@ Create a script, e.g., `problem_recommender.py`:
 
 ```python
 import asyncio
-from pathlib import Path
 from typing import Any
 
 from dotenv import load_dotenv
 from pydantic import BaseModel, Field
 
-from grasp_agents.grasp_logging import setup_logging
+from grasp_agents import LLMAgent, BaseTool, RunContext, Printer
 from grasp_agents.litellm import LiteLLM, LiteLLMSettings
-from grasp_agents import LLMAgent, BaseTool, RunContext
-
-load_dotenv()
 
 
-# Configure the logger to output to the console and/or a file
-setup_logging(
-    logs_file_path="grasp_agents_demo.log",
-    logs_config_path=Path().cwd() / "configs/logging/default.yaml",
-)
+load_dotenv()
 
 sys_prompt_react = """
 Your task is to suggest an exciting stats problem to the student. 
@@ -145,7 +137,7 @@ Returns:
 """
 
 
-class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, Any]):
+class AskStudentTool(BaseTool[TeacherQuestion, StudentReply, None]):
     name: str = "ask_student"
     description: str = ask_student_tool_description
 
@@ -159,11 +151,7 @@ class Problem(BaseModel):
 
 teacher = LLMAgent[None, Problem, None](
     name="teacher",
-    llm=LiteLLM(
-        model_name="gpt-4.1",
-        # model_name="claude-sonnet-4-20250514",
-        # llm_settings=LiteLLMSettings(reasoning_effort="low"),
-    ),
+    llm=LiteLLM(model_name="gpt-4.1"),
     tools=[AskStudentTool()],
     react_mode=True,
     final_answer_as_tool_call=True,
@@ -171,7 +159,7 @@ teacher = LLMAgent[None, Problem, None](
 )
 
 async def main():
-    ctx = RunContext[None](log_messages=True)
+    ctx = RunContext[None](printer=Printer())
     out = await teacher.run("start", ctx=ctx)
     print(out.payloads[0])
     print(ctx.usage_tracker.total_usage)

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/pyproject.toml

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

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/__init__.py

@@ -6,6 +6,7 @@ from .llm_agent import LLMAgent
 from .llm_agent_memory import LLMAgentMemory
 from .memory import Memory
 from .packet import Packet
+from .printer import Printer, print_event_stream
 from .processors.base_processor import BaseProcessor
 from .processors.parallel_processor import ParallelProcessor
 from .processors.processor import Processor
@@ -33,9 +34,11 @@ __all__ = [
     "Packet",
     "Packet",
     "ParallelProcessor",
+    "Printer",
     "ProcName",
     "Processor",
     "RunContext",
     "SystemMessage",
     "UserMessage",
+    "print_event_stream",
 ]

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/cloud_llm.py

@@ -69,6 +69,7 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
         0  # LLM response retries: try to regenerate to pass validation
     )
     apply_response_schema_via_provider: bool = False
+    apply_tool_call_schema_via_provider: bool = False
     async_http_client: httpx.AsyncClient | None = None
     async_http_client_params: dict[str, Any] | AsyncHTTPClientParams | None = None
 
@@ -79,6 +80,9 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
                 f"{self.rate_limiter.rpm} RPM"
             )
 
+        if self.apply_response_schema_via_provider:
+            object.__setattr__(self, "apply_tool_call_schema_via_provider", True)
+
         if self.async_http_client is None and self.async_http_client_params is not None:
             object.__setattr__(
                 self,
@@ -99,7 +103,7 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
         api_tools = None
         api_tool_choice = None
         if tools:
-            strict = True if self.apply_response_schema_via_provider else None
+            strict = True if self.apply_tool_call_schema_via_provider else None
             api_tools = [
                 self.converters.to_tool(t, strict=strict) for t in tools.values()
             ]
@@ -174,8 +178,8 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
                 response_schema=response_schema,
                 response_schema_by_xml_tag=response_schema_by_xml_tag,
             )
-            if tools is not None:
-                self._validate_tool_calls(completion, tools=tools)
+        if not self.apply_tool_call_schema_via_provider and tools is not None:
+            self._validate_tool_calls(completion, tools=tools)
 
         return completion
 
@@ -207,17 +211,16 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
 
                 if n_attempt > self.max_response_retries:
                     if n_attempt == 1:
-                        logger.warning(f"\nCloudLLM completion request failed:\n{err}")
+                        logger.warning(f"\nCloudLLM completion failed:\n{err}")
                     if n_attempt > 1:
                         logger.warning(
-                            f"\nCloudLLM completion request failed after retrying:\n{err}"
+                            f"\nCloudLLM completion failed after retrying:\n{err}"
                         )
                     raise err
                     # return make_refusal_completion(self._model_name, err)
 
                 logger.warning(
-                    f"\nCloudLLM completion request failed (retry attempt {n_attempt}):"
-                    f"\n{err}"
+                    f"\nCloudLLM completion failed (retry attempt {n_attempt}):\n{err}"
                 )
 
         return make_refusal_completion(
@@ -281,8 +284,8 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
                     response_schema=response_schema,
                     response_schema_by_xml_tag=response_schema_by_xml_tag,
                 )
-                if tools is not None:
-                    self._validate_tool_calls(completion, tools=tools)
+            if not self.apply_tool_call_schema_via_provider and tools is not None:
+                self._validate_tool_calls(completion, tools=tools)
 
         return iterator()
 
@@ -326,11 +329,10 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
                 n_attempt += 1
                 if n_attempt > self.max_response_retries:
                     if n_attempt == 1:
-                        logger.warning(f"\nCloudLLM completion request failed:\n{err}")
+                        logger.warning(f"\nCloudLLM completion failed:\n{err}")
                     if n_attempt > 1:
                         logger.warning(
-                            "\nCloudLLM completion request failed after "
-                            f"retrying:\n{err}"
+                            f"\nCloudLLM completion failed after retrying:\n{err}"
                         )
                         refusal_completion = make_refusal_completion(
                             self.model_name, err
@@ -344,6 +346,5 @@ class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co
                     # return
 
                 logger.warning(
-                    "\nCloudLLM completion request failed "
-                    f"(retry attempt {n_attempt}):\n{err}"
+                    f"\nCloudLLM completion failed (retry attempt {n_attempt}):\n{err}"
                 )

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/generics_utils.py

@@ -159,7 +159,7 @@ class AutoInstanceAttributesMixin:
                 attr_type = resolved_attr_types[attr_name]
                 # attr_type = None if _attr_type is type(None) else _attr_type
             else:
-                attr_type = Any
+                attr_type = object
 
             if attr_name in pyd_private:
                 pyd_private[attr_name] = attr_type

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/litellm/lite_llm.py

@@ -149,6 +149,9 @@ class LiteLLM(CloudLLM[LiteLLMSettings, LiteLLMConverters]):
         n_choices: int | None = None,
         **api_llm_settings: Any,
     ) -> LiteLLMCompletion:
+        if api_llm_settings and api_llm_settings.get("stream_options"):
+            api_llm_settings.pop("stream_options")
+
         completion = await litellm.acompletion(  # type: ignore[no-untyped-call]
             model=self.model_name,
             messages=api_messages,

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/llm_agent.py

@@ -310,12 +310,9 @@ class LLMAgent(
         yield ProcPayloadOutputEvent(data=output, proc_name=self.name, call_id=call_id)
 
     def _print_messages(
-        self,
-        messages: Sequence[Message],
-        ctx: RunContext[CtxT],
-        call_id: str,
+        self, messages: Sequence[Message], ctx: RunContext[CtxT], call_id: str
     ) -> None:
-        if ctx and ctx.printer:
+        if ctx.printer:
             ctx.printer.print_messages(messages, agent_name=self.name, call_id=call_id)
 
     # -- Override these methods in subclasses if needed --

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/llm_policy_executor.py

@@ -161,14 +161,11 @@ class LLMPolicyExecutor(Generic[CtxT]):
             response_schema_by_xml_tag=self.response_schema_by_xml_tag,
             tools=self.tools,
             tool_choice=tool_choice,
-            n_choices=1,
             proc_name=self.agent_name,
             call_id=call_id,
         )
         memory.update(completion.messages)
-        self._process_completion(
-            completion, ctx=ctx, call_id=call_id, print_messages=True
-        )
+        self._process_completion(completion, ctx=ctx, call_id=call_id)
 
         return completion.messages[0]
 
@@ -193,7 +190,6 @@ class LLMPolicyExecutor(Generic[CtxT]):
             response_schema_by_xml_tag=self.response_schema_by_xml_tag,
             tools=self.tools,
             tool_choice=tool_choice,
-            n_choices=1,
             proc_name=self.agent_name,
             call_id=call_id,
         )
@@ -212,9 +208,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
 
         memory.update(completion.messages)
 
-        self._process_completion(
-            completion, print_messages=True, ctx=ctx, call_id=call_id
-        )
+        self._process_completion(completion, ctx=ctx, call_id=call_id)
 
     async def call_tools(
         self,
@@ -237,7 +231,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
 
         memory.update(tool_messages)
 
-        if ctx and ctx.printer:
+        if ctx.printer:
             ctx.printer.print_messages(
                 tool_messages, agent_name=self.agent_name, call_id=call_id
             )
@@ -283,7 +277,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
             "Exceeded the maximum number of turns: provide a final answer now!"
         )
         memory.update([user_message])
-        if ctx and ctx.printer:
+        if ctx.printer:
             ctx.printer.print_messages(
                 [user_message], agent_name=self.agent_name, call_id=call_id
             )
@@ -309,7 +303,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
         yield UserMessageEvent(
             proc_name=self.agent_name, call_id=call_id, data=user_message
         )
-        if ctx and ctx.printer:
+        if ctx.printer:
             ctx.printer.print_messages(
                 [user_message], agent_name=self.agent_name, call_id=call_id
             )
@@ -507,12 +501,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
         return FinalAnswerTool()
 
     def _process_completion(
-        self,
-        completion: Completion,
-        *,
-        print_messages: bool = False,
-        ctx: RunContext[CtxT],
-        call_id: str,
+        self, completion: Completion, *, ctx: RunContext[CtxT], call_id: str
     ) -> None:
         ctx.completions[self.agent_name].append(completion)
         ctx.usage_tracker.update(
@@ -520,7 +509,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
             completions=[completion],
             model_name=self.llm.model_name,
         )
-        if ctx.printer and print_messages:
+        if ctx.printer:
             usages = [None] * (len(completion.messages) - 1) + [completion.usage]
             ctx.printer.print_messages(
                 completion.messages,

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/openai/openai_llm.py

@@ -172,6 +172,9 @@ class OpenAILLM(CloudLLM[OpenAILLMSettings, OpenAIConverters]):
         response_format = api_response_schema or NOT_GIVEN
         n = n_choices or NOT_GIVEN
 
+        if api_llm_settings and api_llm_settings.get("stream_options"):
+            api_llm_settings.pop("stream_options")
+
         if self.apply_response_schema_via_provider:
             return await self.client.beta.chat.completions.parse(
                 model=self.model_name,

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/printer.py

@@ -72,50 +72,61 @@ ColoringMode: TypeAlias = Literal["agent", "role"]
 CompletionBlockType: TypeAlias = Literal["response", "thinking", "tool_call"]
 
 
-class Printer:
-    def __init__(
-        self, color_by: ColoringMode = "role", msg_trunc_len: int = 20000
-    ) -> None:
-        self.color_by = color_by
-        self.msg_trunc_len = msg_trunc_len
-        self._current_message: str = ""
+def stream_colored_text(new_colored_text: str) -> None:
+    sys.stdout.write(new_colored_text)
+    sys.stdout.flush()
 
-    @staticmethod
-    def get_role_color(role: Role) -> Color:
-        return ROLE_TO_COLOR[role]
 
-    @staticmethod
-    def get_agent_color(agent_name: str) -> Color:
+def get_color(
+    agent_name: str = "", role: Role = Role.ASSISTANT, color_by: ColoringMode = "role"
+) -> Color:
+    if color_by == "agent":
         idx = int(
             hashlib.md5(agent_name.encode()).hexdigest(),  # noqa :S324
             16,
         ) % len(AVAILABLE_COLORS)
 
         return AVAILABLE_COLORS[idx]
+    return ROLE_TO_COLOR[role]
+
 
-    @staticmethod
-    def content_to_str(content: Content | str | None, role: Role) -> str:
-        if role == Role.USER and isinstance(content, Content):
-            content_str_parts: list[str] = []
-            for content_part in content.parts:
-                if isinstance(content_part, ContentPartText):
-                    content_str_parts.append(content_part.data.strip(" \n"))
-                elif content_part.data.type == "url":
-                    content_str_parts.append(str(content_part.data.url))
-                elif content_part.data.type == "base64":
-                    content_str_parts.append("<ENCODED_IMAGE>")
-            return "\n".join(content_str_parts)
+def content_to_str(content: Content | str | None, role: Role) -> str:
+    if role == Role.USER and isinstance(content, Content):
+        content_str_parts: list[str] = []
+        for content_part in content.parts:
+            if isinstance(content_part, ContentPartText):
+                content_str_parts.append(content_part.data.strip(" \n"))
+            elif content_part.data.type == "url":
+                content_str_parts.append(str(content_part.data.url))
+            elif content_part.data.type == "base64":
+                content_str_parts.append("<ENCODED_IMAGE>")
+        return "\n".join(content_str_parts)
 
-        assert isinstance(content, str | None)
+    assert isinstance(content, str | None)
 
-        return (content or "").strip(" \n")
+    return (content or "").strip(" \n")
 
-    @staticmethod
-    def truncate_content_str(content_str: str, trunc_len: int = 2000) -> str:
-        if len(content_str) > trunc_len:
-            return content_str[:trunc_len] + "[...]"
 
-        return content_str
+def truncate_content_str(content_str: str, trunc_len: int = 2000) -> str:
+    if len(content_str) > trunc_len:
+        return content_str[:trunc_len] + "[...]"
+
+    return content_str
+
+
+class Printer:
+    def __init__(
+        self,
+        color_by: ColoringMode = "role",
+        msg_trunc_len: int = 20000,
+        output_to: Literal["print", "log"] = "print",
+        logging_level: Literal["info", "debug", "warning", "error"] = "info",
+    ) -> None:
+        self.color_by: ColoringMode = color_by
+        self.msg_trunc_len = msg_trunc_len
+        self._current_message: str = ""
+        self._logging_level = logging_level
+        self._output_to = output_to
 
     def print_message(
         self,
@@ -128,11 +139,8 @@ class Printer:
             raise ValueError(
                 "Usage information can only be printed for AssistantMessage"
             )
-
-        color = (
-            self.get_agent_color(agent_name)
-            if self.color_by == "agent"
-            else self.get_role_color(message.role)
+        color = get_color(
+            agent_name=agent_name, role=message.role, color_by=self.color_by
         )
         log_kwargs = {"extra": {"color": color}}
 
@@ -144,13 +152,13 @@ class Printer:
             out += f"<thinking>\n{thinking}\n</thinking>\n"
 
         # Content
-        content = self.content_to_str(message.content or "", message.role)
+        content = content_to_str(message.content or "", message.role)
         if content:
             try:
                 content = json.dumps(json.loads(content), indent=2)
             except Exception:
                 pass
-            content = self.truncate_content_str(content, trunc_len=self.msg_trunc_len)
+            content = truncate_content_str(content, trunc_len=self.msg_trunc_len)
             if isinstance(message, SystemMessage):
                 out += f"<system>\n{content}\n</system>\n"
             elif isinstance(message, UserMessage):
@@ -176,7 +184,17 @@ class Printer:
 
             out += f"\n------------------------------------\n{usage_str}\n"
 
-        logger.debug(out, **log_kwargs)  # type: ignore
+        if self._output_to == "log":
+            if self._logging_level == "debug":
+                logger.debug(out, **log_kwargs)  # type: ignore
+            elif self._logging_level == "info":
+                logger.info(out, **log_kwargs)  # type: ignore
+            elif self._logging_level == "warning":
+                logger.warning(out, **log_kwargs)  # type: ignore
+            else:
+                logger.error(out, **log_kwargs)  # type: ignore
+        else:
+            stream_colored_text(colored(out + "\n", color))
 
     def print_messages(
         self,
@@ -193,28 +211,101 @@ class Printer:
             )
 
 
-def stream_text(new_text: str, color: Color) -> None:
-    sys.stdout.write(colored(new_text, color))
-    sys.stdout.flush()
-
-
 async def print_event_stream(
     event_generator: AsyncIterator[Event[Any]],
     color_by: ColoringMode = "role",
     trunc_len: int = 10000,
 ) -> AsyncIterator[Event[Any]]:
-    color = Printer.get_role_color(Role.ASSISTANT)
+    def _make_chunk_text(event: CompletionChunkEvent[CompletionChunk]) -> str:
+        color = get_color(
+            agent_name=event.proc_name or "", role=Role.ASSISTANT, color_by=color_by
+        )
+        text = ""
+
+        if isinstance(event, CompletionStartEvent):
+            text += f"\n<{event.proc_name}> [{event.call_id}]\n"
+        elif isinstance(event, ThinkingStartEvent):
+            text += "<thinking>\n"
+        elif isinstance(event, ResponseStartEvent):
+            text += "<response>\n"
+        elif isinstance(event, ToolCallStartEvent):
+            tc = event.data.tool_call
+            text += f"<tool call> {tc.tool_name} [{tc.id}]\n"
+        elif isinstance(event, AnnotationsStartEvent):
+            text += "<annotations>\n"
+
+        # if isinstance(event, CompletionEndEvent):
+        #     text += f"\n</{event.proc_name}>\n"
+        if isinstance(event, ThinkingEndEvent):
+            text += "\n</thinking>\n"
+        elif isinstance(event, ResponseEndEvent):
+            text += "\n</response>\n"
+        elif isinstance(event, ToolCallEndEvent):
+            text += "\n</tool call>\n"
+        elif isinstance(event, AnnotationsEndEvent):
+            text += "\n</annotations>\n"
+
+        if isinstance(event, ThinkingChunkEvent):
+            thinking = event.data.thinking
+            if isinstance(thinking, str):
+                text += thinking
+            else:
+                text = "\n".join(
+                    [block.get("thinking", "[redacted]") for block in thinking]
+                )
 
-    def _get_color(event: Event[Any], role: Role = Role.ASSISTANT) -> Color:
-        if color_by == "agent":
-            return Printer.get_agent_color(event.proc_name or "")
-        return Printer.get_role_color(role)
+        if isinstance(event, ResponseChunkEvent):
+            text += event.data.response
 
-    def _print_packet(
-        event: ProcPacketOutputEvent | WorkflowResultEvent | RunResultEvent,
-    ) -> None:
-        color = _get_color(event, Role.ASSISTANT)
+        if isinstance(event, ToolCallChunkEvent):
+            text += event.data.tool_call.tool_arguments or ""
 
+        if isinstance(event, AnnotationsChunkEvent):
+            text += "\n".join(
+                [
+                    json.dumps(annotation, indent=2)
+                    for annotation in event.data.annotations
+                ]
+            )
+
+        return colored(text, color)
+
+    def _make_message_text(
+        event: MessageEvent[SystemMessage | UserMessage | ToolMessage],
+    ) -> str:
+        message = event.data
+        role = message.role
+        content = content_to_str(message.content, role=role)
+
+        color = get_color(
+            agent_name=event.proc_name or "", role=role, color_by=color_by
+        )
+        text = f"\n<{event.proc_name}> [{event.call_id}]\n"
+
+        if isinstance(event, (SystemMessageEvent, UserMessageEvent)):
+            content = truncate_content_str(content, trunc_len=trunc_len)
+
+        if isinstance(event, SystemMessageEvent):
+            text += f"<system>\n{content}\n</system>\n"
+
+        elif isinstance(event, UserMessageEvent):
+            text += f"<input>\n{content}\n</input>\n"
+
+        elif isinstance(event, ToolMessageEvent):
+            message = event.data
+            try:
+                content = json.dumps(json.loads(content), indent=2)
+            except Exception:
+                pass
+            text += (
+                f"<tool result> [{message.tool_call_id}]\n{content}\n</tool result>\n"
+            )
+
+        return colored(text, color)
+
+    def _make_packet_text(
+        event: ProcPacketOutputEvent | WorkflowResultEvent | RunResultEvent,
+    ) -> str:
         if isinstance(event, WorkflowResultEvent):
             src = "workflow"
         elif isinstance(event, RunResultEvent):
@@ -222,6 +313,9 @@ async def print_event_stream(
         else:
             src = "processor"
 
+        color = get_color(
+            agent_name=event.proc_name or "", role=Role.ASSISTANT, color_by=color_by
+        )
         text = f"\n<{event.proc_name}> [{event.call_id}]\n"
 
         if event.data.payloads:
@@ -237,7 +331,9 @@ async def print_event_stream(
                 text += f"{p_str}\n"
             text += f"</{src} output>\n"
 
-        stream_text(text, color)
+        return colored(text, color)
+
+    # ------ Wrap event generator -------
 
     async for event in event_generator:
         yield event
@@ -245,91 +341,12 @@ async def print_event_stream(
         if isinstance(event, CompletionChunkEvent) and isinstance(
             event.data, CompletionChunk
         ):
-            color = _get_color(event, Role.ASSISTANT)
-
-            text = ""
-
-            if isinstance(event, CompletionStartEvent):
-                text += f"\n<{event.proc_name}> [{event.call_id}]\n"
-            elif isinstance(event, ThinkingStartEvent):
-                text += "<thinking>\n"
-            elif isinstance(event, ResponseStartEvent):
-                text += "<response>\n"
-            elif isinstance(event, ToolCallStartEvent):
-                tc = event.data.tool_call
-                text += f"<tool call> {tc.tool_name} [{tc.id}]\n"
-            elif isinstance(event, AnnotationsStartEvent):
-                text += "<annotations>\n"
-
-            # if isinstance(event, CompletionEndEvent):
-            #     text += f"\n</{event.proc_name}>\n"
-            if isinstance(event, ThinkingEndEvent):
-                text += "\n</thinking>\n"
-            elif isinstance(event, ResponseEndEvent):
-                text += "\n</response>\n"
-            elif isinstance(event, ToolCallEndEvent):
-                text += "\n</tool call>\n"
-            elif isinstance(event, AnnotationsEndEvent):
-                text += "\n</annotations>\n"
-
-            if isinstance(event, ThinkingChunkEvent):
-                thinking = event.data.thinking
-                if isinstance(thinking, str):
-                    text += thinking
-                else:
-                    text = "\n".join(
-                        [block.get("thinking", "[redacted]") for block in thinking]
-                    )
-
-            if isinstance(event, ResponseChunkEvent):
-                text += event.data.response
-
-            if isinstance(event, ToolCallChunkEvent):
-                text += event.data.tool_call.tool_arguments or ""
-
-            if isinstance(event, AnnotationsChunkEvent):
-                text += "\n".join(
-                    [
-                        json.dumps(annotation, indent=2)
-                        for annotation in event.data.annotations
-                    ]
-                )
-
-            stream_text(text, color)
+            stream_colored_text(_make_chunk_text(event))
 
         if isinstance(event, MessageEvent) and not isinstance(event, GenMessageEvent):
-            assert isinstance(event.data, (SystemMessage | UserMessage | ToolMessage))
-
-            message = event.data
-            role = message.role
-            content = Printer.content_to_str(message.content, role=role)
-            color = _get_color(event, role)
-
-            text = f"\n<{event.proc_name}> [{event.call_id}]\n"
-
-            if isinstance(event, (SystemMessageEvent, UserMessageEvent)):
-                content = Printer.truncate_content_str(content, trunc_len=trunc_len)
-
-            if isinstance(event, SystemMessageEvent):
-                text += f"<system>\n{content}\n</system>\n"
-
-            elif isinstance(event, UserMessageEvent):
-                text += f"<input>\n{content}\n</input>\n"
-
-            elif isinstance(event, ToolMessageEvent):
-                message = event.data
-                try:
-                    content = json.dumps(json.loads(content), indent=2)
-                except Exception:
-                    pass
-                text += (
-                    f"<tool result> [{message.tool_call_id}]\n"
-                    f"{content}\n</tool result>\n"
-                )
-
-            stream_text(text, color)
+            stream_colored_text(_make_message_text(event))
 
         if isinstance(
             event, (ProcPacketOutputEvent, WorkflowResultEvent, RunResultEvent)
         ):
-            _print_packet(event)
+            stream_colored_text(_make_packet_text(event))

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/processors/base_processor.py

@@ -60,11 +60,13 @@ def with_retry(func: F) -> F:
                         logger.warning(f"{err_message}:\n{err}")
                     else:
                         logger.warning(f"{err_message} after retrying:\n{err}")
-                    raise ProcRunError(proc_name=self.name, call_id=call_id) from err
+                    # raise ProcRunError(proc_name=self.name, call_id=call_id) from err
+                    return None  # type: ignore[return]
 
                 logger.warning(f"{err_message} (retry attempt {n_attempt + 1}):\n{err}")
         # This part should not be reachable due to the raise in the loop
-        raise ProcRunError(proc_name=self.name, call_id=call_id)
+        # raise ProcRunError(proc_name=self.name, call_id=call_id)
+        return None  # type: ignore[return]
 
     return cast("F", wrapper)
 

{grasp_agents-0.5.11 → grasp_agents-0.5.12}/src/grasp_agents/run_context.py

@@ -1,11 +1,11 @@
 from collections import defaultdict
-from typing import Any, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from grasp_agents.typing.completion import Completion
 
-from .printer import ColoringMode, Printer
+from .printer import Printer
 from .typing.io import ProcName
 from .usage_tracker import UsageTracker
 
@@ -19,13 +19,6 @@ class RunContext(BaseModel, Generic[CtxT]):
         default_factory=lambda: defaultdict(list)
     )
     usage_tracker: UsageTracker = Field(default_factory=UsageTracker)
-
     printer: Printer | None = None
-    log_messages: bool = False
-    color_messages_by: ColoringMode = "role"
-
-    def model_post_init(self, context: Any) -> None:  # noqa: ARG002
-        if self.log_messages:
-            self.printer = Printer(color_by=self.color_messages_by)
 
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)