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

grasp_agents/llm_policy_executor.py

@@ -37,6 +37,7 @@ class ToolCallLoopTerminator(Protocol[CtxT]):
         conversation: Messages,
         *,
         ctx: RunContext[CtxT],
+        call_id: str,
         **kwargs: Any,
     ) -> bool: ...
 
@@ -47,6 +48,7 @@ class MemoryManager(Protocol[CtxT]):
         memory: LLMAgentMemory,
         *,
         ctx: RunContext[CtxT],
+        call_id: str,
         **kwargs: Any,
     ) -> None: ...
 
@@ -123,10 +125,13 @@ class LLMPolicyExecutor(Generic[CtxT]):
         conversation: Messages,
         *,
         ctx: RunContext[CtxT],
+        call_id: str,
         **kwargs: Any,
     ) -> bool:
         if self.tool_call_loop_terminator:
-            return self.tool_call_loop_terminator(conversation, ctx=ctx, **kwargs)
+            return self.tool_call_loop_terminator(
+                conversation, ctx=ctx, call_id=call_id, **kwargs
+            )
 
         return False
 
@@ -136,18 +141,19 @@ class LLMPolicyExecutor(Generic[CtxT]):
         memory: LLMAgentMemory,
         *,
         ctx: RunContext[CtxT],
+        call_id: str,
         **kwargs: Any,
     ) -> None:
         if self.memory_manager:
-            self.memory_manager(memory=memory, ctx=ctx, **kwargs)
+            self.memory_manager(memory=memory, ctx=ctx, call_id=call_id, **kwargs)
 
     async def generate_message(
         self,
         memory: LLMAgentMemory,
         *,
-        call_id: str,
         tool_choice: ToolChoice | None = None,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> AssistantMessage:
         completion = await self.llm.generate_completion(
             memory.message_history,
@@ -155,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, call_id=call_id, ctx=ctx, print_messages=True
-        )
+        self._process_completion(completion, ctx=ctx, call_id=call_id)
 
         return completion.messages[0]
 
@@ -170,9 +173,9 @@ class LLMPolicyExecutor(Generic[CtxT]):
         self,
         memory: LLMAgentMemory,
         *,
-        call_id: str,
         tool_choice: ToolChoice | None = None,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> AsyncIterator[
         CompletionChunkEvent[CompletionChunk]
         | CompletionEvent
@@ -187,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,
         )
@@ -206,23 +208,21 @@ class LLMPolicyExecutor(Generic[CtxT]):
 
         memory.update(completion.messages)
 
-        self._process_completion(
-            completion, call_id=call_id, print_messages=True, ctx=ctx
-        )
+        self._process_completion(completion, ctx=ctx, call_id=call_id)
 
     async def call_tools(
         self,
         calls: Sequence[ToolCall],
         memory: LLMAgentMemory,
-        call_id: str,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> Sequence[ToolMessage]:
         # TODO: Add image support
         corouts: list[Coroutine[Any, Any, BaseModel]] = []
         for call in calls:
             tool = self.tools[call.tool_name]
             args = json.loads(call.tool_arguments)
-            corouts.append(tool(call_id=call_id, ctx=ctx, **args))
+            corouts.append(tool(ctx=ctx, call_id=call_id, **args))
 
         outs = await asyncio.gather(*corouts)
         tool_messages = list(
@@ -231,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
             )
@@ -242,11 +242,11 @@ class LLMPolicyExecutor(Generic[CtxT]):
         self,
         calls: Sequence[ToolCall],
         memory: LLMAgentMemory,
-        call_id: str,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> AsyncIterator[ToolMessageEvent]:
         tool_messages = await self.call_tools(
-            calls, memory=memory, call_id=call_id, ctx=ctx
+            calls, memory=memory, ctx=ctx, call_id=call_id
         )
         for tool_message, call in zip(tool_messages, calls, strict=True):
             yield ToolMessageEvent(
@@ -271,20 +271,20 @@ class LLMPolicyExecutor(Generic[CtxT]):
                 return final_answer_message
 
     async def _generate_final_answer(
-        self, memory: LLMAgentMemory, call_id: str, ctx: RunContext[CtxT]
+        self, memory: LLMAgentMemory, ctx: RunContext[CtxT], call_id: str
     ) -> AssistantMessage:
         user_message = UserMessage.from_text(
             "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
             )
 
         tool_choice = NamedToolChoice(name=self._final_answer_tool.name)
         await self.generate_message(
-            memory, tool_choice=tool_choice, call_id=call_id, ctx=ctx
+            memory, tool_choice=tool_choice, ctx=ctx, call_id=call_id
         )
 
         final_answer_message = self._extract_final_answer_from_tool_calls(memory=memory)
@@ -294,7 +294,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
         return final_answer_message
 
     async def _generate_final_answer_stream(
-        self, memory: LLMAgentMemory, call_id: str, ctx: RunContext[CtxT]
+        self, memory: LLMAgentMemory, ctx: RunContext[CtxT], call_id: str
     ) -> AsyncIterator[Event[Any]]:
         user_message = UserMessage.from_text(
             "Exceeded the maximum number of turns: provide a final answer now!",
@@ -303,14 +303,14 @@ 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
             )
 
         tool_choice = NamedToolChoice(name=self._final_answer_tool.name)
         async for event in self.generate_message_stream(
-            memory, tool_choice=tool_choice, call_id=call_id, ctx=ctx
+            memory, tool_choice=tool_choice, ctx=ctx, call_id=call_id
         ):
             yield event
 
@@ -322,7 +322,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
         )
 
     async def execute(
-        self, memory: LLMAgentMemory, call_id: str, ctx: RunContext[CtxT]
+        self, memory: LLMAgentMemory, ctx: RunContext[CtxT], call_id: str
     ) -> AssistantMessage | Sequence[AssistantMessage]:
         # 1. Generate the first message:
         #    In ReAct mode, we generate the first message without tool calls
@@ -332,7 +332,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
         if self.tools:
             tool_choice = "none" if self._react_mode else "auto"
         gen_message = await self.generate_message(
-            memory, tool_choice=tool_choice, call_id=call_id, ctx=ctx
+            memory, tool_choice=tool_choice, ctx=ctx, call_id=call_id
         )
         if not self.tools:
             return gen_message
@@ -345,7 +345,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
             # If a final answer is not provided via a tool call, we use
             # _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
+                memory.message_history, ctx=ctx, call_id=call_id, num_turns=turns
             ):
                 return gen_message
 
@@ -364,7 +364,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
                 # Otherwise, we simply return the last generated message.
                 if self._final_answer_as_tool_call:
                     final_answer = await self._generate_final_answer(
-                        memory, call_id=call_id, ctx=ctx
+                        memory, ctx=ctx, call_id=call_id
                     )
                 else:
                     final_answer = gen_message
@@ -377,11 +377,11 @@ class LLMPolicyExecutor(Generic[CtxT]):
 
             if gen_message.tool_calls:
                 await self.call_tools(
-                    gen_message.tool_calls, memory=memory, call_id=call_id, ctx=ctx
+                    gen_message.tool_calls, memory=memory, ctx=ctx, call_id=call_id
                 )
 
             # Apply memory management (e.g. compacting or pruning memory)
-            self._manage_memory(memory, ctx=ctx, num_turns=turns)
+            self._manage_memory(memory, ctx=ctx, call_id=call_id, num_turns=turns)
 
             # 4. Generate the next message based on the updated memory.
             #    In ReAct mode, we set tool_choice to "none" if we just called tools,
@@ -396,7 +396,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
                 tool_choice = "required"
 
             gen_message = await self.generate_message(
-                memory, tool_choice=tool_choice, call_id=call_id, ctx=ctx
+                memory, tool_choice=tool_choice, ctx=ctx, call_id=call_id
             )
 
             turns += 1
@@ -404,13 +404,13 @@ class LLMPolicyExecutor(Generic[CtxT]):
     async def execute_stream(
         self,
         memory: LLMAgentMemory,
-        call_id: str,
         ctx: RunContext[CtxT],
+        call_id: str,
     ) -> AsyncIterator[Event[Any]]:
         tool_choice: ToolChoice = "none" if self._react_mode else "auto"
         gen_message: AssistantMessage | None = None
         async for event in self.generate_message_stream(
-            memory, tool_choice=tool_choice, call_id=call_id, ctx=ctx
+            memory, tool_choice=tool_choice, ctx=ctx, call_id=call_id
         ):
             if isinstance(event, GenMessageEvent):
                 gen_message = event.data
@@ -425,7 +425,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
 
         while True:
             if not self._final_answer_as_tool_call and self._terminate_tool_call_loop(
-                memory.message_history, ctx=ctx, num_turns=turns
+                memory.message_history, ctx=ctx, call_id=call_id, num_turns=turns
             ):
                 return
 
@@ -444,7 +444,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
             if turns >= self.max_turns:
                 if self._final_answer_as_tool_call:
                     async for event in self._generate_final_answer_stream(
-                        memory, call_id=call_id, ctx=ctx
+                        memory, ctx=ctx, call_id=call_id
                     ):
                         yield event
                 logger.info(
@@ -459,11 +459,11 @@ class LLMPolicyExecutor(Generic[CtxT]):
                     )
 
                 async for event in self.call_tools_stream(
-                    gen_message.tool_calls, memory=memory, call_id=call_id, ctx=ctx
+                    gen_message.tool_calls, memory=memory, ctx=ctx, call_id=call_id
                 ):
                     yield event
 
-            self._manage_memory(memory, ctx=ctx, num_turns=turns)
+            self._manage_memory(memory, ctx=ctx, call_id=call_id, num_turns=turns)
 
             if self._react_mode and gen_message.tool_calls:
                 tool_choice = "none"
@@ -473,7 +473,7 @@ class LLMPolicyExecutor(Generic[CtxT]):
                 tool_choice = "required"
 
             async for event in self.generate_message_stream(
-                memory, tool_choice=tool_choice, call_id=call_id, ctx=ctx
+                memory, tool_choice=tool_choice, ctx=ctx, call_id=call_id
             ):
                 yield event
                 if isinstance(event, GenMessageEvent):
@@ -493,20 +493,15 @@ class LLMPolicyExecutor(Generic[CtxT]):
                 self,
                 inp: BaseModel,
                 *,
-                call_id: str | None = None,
                 ctx: RunContext[Any] | None = None,
+                call_id: str | None = None,
             ) -> None:
                 return None
 
         return FinalAnswerTool()
 
     def _process_completion(
-        self,
-        completion: Completion,
-        *,
-        call_id: str,
-        print_messages: bool = False,
-        ctx: RunContext[CtxT],
+        self, completion: Completion, *, ctx: RunContext[CtxT], call_id: str
     ) -> None:
         ctx.completions[self.agent_name].append(completion)
         ctx.usage_tracker.update(
@@ -514,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/openai/openai_llm.py

@@ -60,7 +60,7 @@ def get_openai_compatible_providers() -> list[APIProvider]:
 
 
 class OpenAILLMSettings(CloudLLMSettings, total=False):
-    reasoning_effort: Literal["low", "medium", "high"] | None
+    reasoning_effort: Literal["disable", "minimal", "low", "medium", "high"] | None
 
     parallel_tool_calls: bool
 
@@ -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,