grasp_agents 0.5.10__py3-none-any.whl → 0.5.12__py3-none-any.whl

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/cloud_llm.py

@@ -61,7 +61,6 @@ LLMRateLimiter = RateLimiterC[
 
 @dataclass(frozen=True)
 class CloudLLM(LLM[SettingsT_co, ConvertT_co], Generic[SettingsT_co, ConvertT_co]):
-    # Make this field keyword-only to avoid ordering issues with inherited defaulted fields
     api_provider: APIProvider | None = None
     llm_settings: SettingsT_co | None = None
     rate_limiter: LLMRateLimiter | None = None
@@ -70,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
 
@@ -80,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,
@@ -100,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()
             ]
@@ -175,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
 
@@ -208,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(
@@ -282,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()
 
@@ -327,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
@@ -345,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/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/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/llm_agent.py

@@ -42,6 +42,7 @@ class OutputParser(Protocol[_InT_contra, _OutT_co, CtxT]):
         *,
         in_args: _InT_contra | None,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> _OutT_co: ...
 
 
@@ -169,10 +170,15 @@ class LLMAgent(
         in_args: InT | None = None,
         sys_prompt: LLMPrompt | None = None,
         ctx: RunContext[Any],
+        call_id: str,
     ) -> None:
         if self.memory_preparator:
             return self.memory_preparator(
-                memory=memory, in_args=in_args, sys_prompt=sys_prompt, ctx=ctx
+                memory=memory,
+                in_args=in_args,
+                sys_prompt=sys_prompt,
+                ctx=ctx,
+                call_id=call_id,
             )
 
     def _memorize_inputs(
@@ -182,8 +188,11 @@ class LLMAgent(
         chat_inputs: LLMPrompt | Sequence[str | ImageData] | None = None,
         in_args: InT | None = None,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> tuple[SystemMessage | None, UserMessage | None]:
-        formatted_sys_prompt = self._prompt_builder.build_system_prompt(ctx=ctx)
+        formatted_sys_prompt = self._prompt_builder.build_system_prompt(
+            ctx=ctx, call_id=call_id
+        )
 
         system_message: SystemMessage | None = None
         if self._reset_memory_on_run or memory.is_empty:
@@ -192,24 +201,22 @@ class LLMAgent(
                 system_message = cast("SystemMessage", memory.message_history[0])
         else:
             self._prepare_memory(
-                memory=memory, in_args=in_args, sys_prompt=formatted_sys_prompt, ctx=ctx
+                memory=memory,
+                in_args=in_args,
+                sys_prompt=formatted_sys_prompt,
+                ctx=ctx,
+                call_id=call_id,
             )
 
         input_message = self._prompt_builder.build_input_message(
-            chat_inputs=chat_inputs, in_args=in_args, ctx=ctx
+            chat_inputs=chat_inputs, in_args=in_args, ctx=ctx, call_id=call_id
         )
         if input_message:
             memory.update([input_message])
 
         return system_message, input_message
 
-    def _parse_output_default(
-        self,
-        conversation: Messages,
-        *,
-        in_args: InT | None = None,
-        ctx: RunContext[CtxT],
-    ) -> OutT:
+    def parse_output_default(self, conversation: Messages) -> OutT:
         return validate_obj_from_json_or_py_string(
             str(conversation[-1].content or ""),
             schema=self._out_type,
@@ -223,15 +230,14 @@ class LLMAgent(
         *,
         in_args: InT | None = None,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> OutT:
         if self.output_parser:
             return self.output_parser(
-                conversation=conversation, in_args=in_args, ctx=ctx
+                conversation=conversation, in_args=in_args, ctx=ctx, call_id=call_id
             )
 
-        return self._parse_output_default(
-            conversation=conversation, in_args=in_args, ctx=ctx
-        )
+        return self.parse_output_default(conversation)
 
     async def _process(
         self,
@@ -239,24 +245,28 @@ class LLMAgent(
         *,
         in_args: InT | None = None,
         memory: LLMAgentMemory,
-        call_id: str,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> OutT:
         system_message, input_message = self._memorize_inputs(
             memory=memory,
             chat_inputs=chat_inputs,
             in_args=in_args,
             ctx=ctx,
+            call_id=call_id,
         )
         if system_message:
-            self._print_messages([system_message], call_id=call_id, ctx=ctx)
+            self._print_messages([system_message], ctx=ctx, call_id=call_id)
         if input_message:
-            self._print_messages([input_message], call_id=call_id, ctx=ctx)
+            self._print_messages([input_message], ctx=ctx, call_id=call_id)
 
-        await self._policy_executor.execute(memory, call_id=call_id, ctx=ctx)
+        await self._policy_executor.execute(memory, ctx=ctx, call_id=call_id)
 
         return self._parse_output(
-            conversation=memory.message_history, in_args=in_args, ctx=ctx
+            conversation=memory.message_history,
+            in_args=in_args,
+            ctx=ctx,
+            call_id=call_id,
         )
 
     async def _process_stream(
@@ -265,43 +275,44 @@ class LLMAgent(
         *,
         in_args: InT | None = None,
         memory: LLMAgentMemory,
-        call_id: str,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> AsyncIterator[Event[Any]]:
         system_message, input_message = self._memorize_inputs(
             memory=memory,
             chat_inputs=chat_inputs,
             in_args=in_args,
             ctx=ctx,
+            call_id=call_id,
         )
         if system_message:
-            self._print_messages([system_message], call_id=call_id, ctx=ctx)
+            self._print_messages([system_message], ctx=ctx, call_id=call_id)
             yield SystemMessageEvent(
                 data=system_message, proc_name=self.name, call_id=call_id
             )
         if input_message:
-            self._print_messages([input_message], call_id=call_id, ctx=ctx)
+            self._print_messages([input_message], ctx=ctx, call_id=call_id)
             yield UserMessageEvent(
                 data=input_message, proc_name=self.name, call_id=call_id
             )
 
         async for event in self._policy_executor.execute_stream(
-            memory, call_id=call_id, ctx=ctx
+            memory, ctx=ctx, call_id=call_id
         ):
             yield event
 
         output = self._parse_output(
-            conversation=memory.message_history, in_args=in_args, ctx=ctx
+            conversation=memory.message_history,
+            in_args=in_args,
+            ctx=ctx,
+            call_id=call_id,
         )
         yield ProcPayloadOutputEvent(data=output, proc_name=self.name, call_id=call_id)
 
     def _print_messages(
-        self,
-        messages: Sequence[Message],
-        call_id: str,
-        ctx: RunContext[CtxT],
+        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 --
@@ -328,31 +339,45 @@ class LLMAgent(
         if cur_cls.memory_manager is not base_cls.memory_manager:
             self._policy_executor.memory_manager = self.memory_manager
 
-    def system_prompt_builder(self, ctx: RunContext[CtxT]) -> str | None:
+    def system_prompt_builder(self, ctx: RunContext[CtxT], call_id: str) -> str | None:
         if self._prompt_builder.system_prompt_builder is not None:
-            return self._prompt_builder.system_prompt_builder(ctx=ctx)
+            return self._prompt_builder.system_prompt_builder(ctx=ctx, call_id=call_id)
         raise NotImplementedError("System prompt builder is not implemented.")
 
-    def input_content_builder(self, in_args: InT, ctx: RunContext[CtxT]) -> Content:
+    def input_content_builder(
+        self, in_args: InT, ctx: RunContext[CtxT], call_id: str
+    ) -> Content:
         if self._prompt_builder.input_content_builder is not None:
-            return self._prompt_builder.input_content_builder(in_args=in_args, ctx=ctx)
+            return self._prompt_builder.input_content_builder(
+                in_args=in_args, ctx=ctx, call_id=call_id
+            )
         raise NotImplementedError("Input content builder is not implemented.")
 
     def tool_call_loop_terminator(
-        self, conversation: Messages, *, ctx: RunContext[CtxT], **kwargs: Any
+        self,
+        conversation: Messages,
+        *,
+        ctx: RunContext[CtxT],
+        call_id: str,
+        **kwargs: Any,
     ) -> bool:
         if self._policy_executor.tool_call_loop_terminator is not None:
             return self._policy_executor.tool_call_loop_terminator(
-                conversation=conversation, ctx=ctx, **kwargs
+                conversation=conversation, ctx=ctx, call_id=call_id, **kwargs
             )
         raise NotImplementedError("Tool call loop terminator is not implemented.")
 
     def memory_manager(
-        self, memory: LLMAgentMemory, *, ctx: RunContext[CtxT], **kwargs: Any
+        self,
+        memory: LLMAgentMemory,
+        *,
+        ctx: RunContext[CtxT],
+        call_id: str,
+        **kwargs: Any,
     ) -> None:
         if self._policy_executor.memory_manager is not None:
             return self._policy_executor.memory_manager(
-                memory=memory, ctx=ctx, **kwargs
+                memory=memory, ctx=ctx, call_id=call_id, **kwargs
             )
         raise NotImplementedError("Memory manager is not implemented.")
 

grasp_agents/llm_agent_memory.py

@@ -17,6 +17,7 @@ class MemoryPreparator(Protocol):
         in_args: Any | None,
         sys_prompt: LLMPrompt | None,
         ctx: RunContext[Any],
+        call_id: str,
     ) -> None: ...