praisonaiagents 0.0.51__tar.gz → 0.0.53__tar.gz

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.51
+Version: 0.0.53
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/praisonaiagents/agent/agent.py

@@ -317,7 +317,8 @@ class Agent:
         max_reflect: int = 3,
         min_reflect: int = 1,
         reflect_llm: Optional[str] = None,
-        user_id: Optional[str] = None
+        user_id: Optional[str] = None,
+        reasoning_steps: bool = False
     ):
         # Add check at start if memory is requested
         if memory is not None:
@@ -425,6 +426,7 @@ Your Goal: {self.goal}
 
         # Store user_id
         self.user_id = user_id or "praison"
+        self.reasoning_steps = reasoning_steps
 
         # Check if knowledge parameter has any values
         if not knowledge:
@@ -526,7 +528,7 @@ Your Goal: {self.goal}
     def __str__(self):
         return f"Agent(name='{self.name}', role='{self.role}', goal='{self.goal}')"
 
-    def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, show_reasoning=False):
+    def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, reasoning_steps=False):
         start_time = time.time()
         logging.debug(f"{self.name} sending messages to LLM: {messages}")
 
@@ -615,7 +617,7 @@ Your Goal: {self.goal}
                             live.update(display_generating(full_response_text, start_time))
                         
                         # Update live display with reasoning content if enabled
-                        if show_reasoning and hasattr(chunk.choices[0].delta, "reasoning_content"):
+                        if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
                             rc = chunk.choices[0].delta.reasoning_content
                             if rc:
                                 reasoning_content += rc
@@ -642,7 +644,8 @@ Your Goal: {self.goal}
             display_error(f"Error in chat completion: {e}")
             return None
 
-    def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, show_reasoning=False):
+    def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False):
+        reasoning_steps = reasoning_steps or self.reasoning_steps
         # Search for existing knowledge if any knowledge is provided
         if self.knowledge:
             search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
@@ -678,7 +681,8 @@ Your Goal: {self.goal}
                     agent_name=self.name,
                     agent_role=self.role,
                     agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools],
-                    execute_tool_fn=self.execute_tool  # Pass tool execution function
+                    execute_tool_fn=self.execute_tool,  # Pass tool execution function
+                    reasoning_steps=reasoning_steps
                 )
 
                 self.chat_history.append({"role": "user", "content": prompt})
@@ -748,7 +752,7 @@ Your Goal: {self.goal}
                                 agent_tools=agent_tools
                             )
 
-                    response = self._chat_completion(messages, temperature=temperature, tools=tools if tools else None, show_reasoning=show_reasoning)
+                    response = self._chat_completion(messages, temperature=temperature, tools=tools if tools else None, reasoning_steps=reasoning_steps)
                     if not response:
                         return None
 
@@ -807,6 +811,9 @@ Your Goal: {self.goal}
                         if self.verbose:
                             logging.debug(f"Agent {self.name} final response: {response_text}")
                         display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                        # Return only reasoning content if reasoning_steps is True
+                        if reasoning_steps and hasattr(response.choices[0].message, 'reasoning_content'):
+                            return response.choices[0].message.reasoning_content
                         return response_text
 
                     reflection_prompt = f"""
@@ -881,8 +888,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             cleaned = cleaned[:-3].strip()
         return cleaned  
 
-    async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None, output_pydantic=None, show_reasoning=False):
+    async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False):
         """Async version of chat method. TODO: Requires Syncing with chat method.""" 
+        reasoning_steps = reasoning_steps or self.reasoning_steps
         try:
             # Search for existing knowledge if any knowledge is provided
             if self.knowledge:
@@ -914,7 +922,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         agent_role=self.role,
                         agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools],
                         execute_tool_fn=self.execute_tool_async,
-                        show_reasoning=show_reasoning
+                        reasoning_steps=reasoning_steps
                     )
 
                     self.chat_history.append({"role": "user", "content": prompt})
@@ -1029,7 +1037,7 @@ Your Goal: {self.goal}
             display_error(f"Error in achat: {e}")
             return None
 
-    async def _achat_completion(self, response, tools, show_reasoning=False):
+    async def _achat_completion(self, response, tools, reasoning_steps=False):
         """Async version of _chat_completion method"""
         try:
             message = response.choices[0].message
@@ -1097,7 +1105,7 @@ Your Goal: {self.goal}
                                     full_response_text += chunk.choices[0].delta.content
                                     live.update(display_generating(full_response_text, start_time))
                                 
-                                if show_reasoning and hasattr(chunk.choices[0].delta, "reasoning_content"):
+                                if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
                                     rc = chunk.choices[0].delta.reasoning_content
                                     if rc:
                                         reasoning_content += rc
@@ -1106,6 +1114,9 @@ Your Goal: {self.goal}
                         self.console.print()
                         
                         final_response = process_stream_chunks(chunks)
+                        # Return only reasoning content if reasoning_steps is True
+                        if reasoning_steps and hasattr(final_response.choices[0].message, 'reasoning_content'):
+                            return final_response.choices[0].message.reasoning_content
                         return final_response.choices[0].message.content if final_response else full_response_text
 
                     except Exception as e:

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/praisonaiagents/agents/agents.py

@@ -390,15 +390,8 @@ Context:
                     task.status = "completed"
                     # Run execute_callback for memory operations
                     try:
-                        try:
-                            # If a loop is already running, just create the task
-                            loop = asyncio.get_running_loop()
-                            loop.create_task(task.execute_callback(task_output))
-                        except RuntimeError:
-                            # Otherwise, create and set a new loop, and run the callback
-                            loop = asyncio.new_event_loop()
-                            asyncio.set_event_loop(loop)
-                            loop.create_task(task.execute_callback(task_output))
+                        # Use the new sync wrapper to avoid pending coroutine issues
+                        task.execute_callback_sync(task_output)
                     except Exception as e:
                         logger.error(f"Error executing memory callback for task {task_id}: {e}")
                         logger.exception(e)
@@ -720,15 +713,8 @@ Context:
                     task.status = "completed"
                     # Run execute_callback for memory operations
                     try:
-                        try:
-                            # If a loop is already running, just create the task
-                            loop = asyncio.get_running_loop()
-                            loop.create_task(task.execute_callback(task_output))
-                        except RuntimeError:
-                            # Otherwise, create and set a new loop, and run the callback
-                            loop = asyncio.new_event_loop()
-                            asyncio.set_event_loop(loop)
-                            loop.create_task(task.execute_callback(task_output))
+                        # Use the new sync wrapper to avoid pending coroutine issues
+                        task.execute_callback_sync(task_output)
                     except Exception as e:
                         logger.error(f"Error executing memory callback for task {task_id}: {e}")
                         logger.exception(e)

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/praisonaiagents/llm/llm.py

@@ -113,6 +113,7 @@ class LLM:
             litellm.callbacks = []
             # Additional logging suppression
             litellm.suppress_debug_messages = True
+            litellm._logging._disable_debugging()
             logging.getLogger("litellm.utils").setLevel(logging.WARNING)
             logging.getLogger("litellm.main").setLevel(logging.WARNING)
         except ImportError:
@@ -147,6 +148,7 @@ class LLM:
         self.self_reflect = extra_settings.get('self_reflect', False)
         self.max_reflect = extra_settings.get('max_reflect', 3)
         self.min_reflect = extra_settings.get('min_reflect', 1)
+        self.reasoning_steps = extra_settings.get('reasoning_steps', False)
         
         # Enable error dropping for cleaner output
         litellm.drop_params = True
@@ -176,7 +178,7 @@ class LLM:
         """Enhanced get_response with all OpenAI-like features"""
         try:
             import litellm
-            
+            reasoning_steps = kwargs.get('reasoning_steps', self.reasoning_steps)
             # Disable litellm debug messages
             litellm.set_verbose = False
             
@@ -230,8 +232,55 @@ class LLM:
 
                     # Get response from LiteLLM
                     start_time = time.time()
-                    if verbose:
-                        with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+
+                    # If reasoning_steps is True, do a single non-streaming call
+                    if reasoning_steps:
+                        resp = litellm.completion(
+                            model=self.model,
+                            messages=messages,
+                            temperature=temperature,
+                            stream=False,  # force non-streaming
+                            **kwargs
+                        )
+                        reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                        response_text = resp["choices"][0]["message"]["content"]
+                        
+                        # Optionally display reasoning if present
+                        if verbose and reasoning_content:
+                            display_interaction(
+                                original_prompt,
+                                f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                        else:
+                            display_interaction(
+                                original_prompt,
+                                response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                    
+                    # Otherwise do the existing streaming approach
+                    else:
+                        if verbose:
+                            with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                                response_text = ""
+                                for chunk in litellm.completion(
+                                    model=self.model,
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    **kwargs
+                                ):
+                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                        content = chunk.choices[0].delta.content
+                                        response_text += content
+                                        live.update(display_generating(response_text, start_time))
+                        else:
+                            # Non-verbose mode, just collect the response
                             response_text = ""
                             for chunk in litellm.completion(
                                 model=self.model,
@@ -241,23 +290,9 @@ class LLM:
                                 **kwargs
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    content = chunk.choices[0].delta.content
-                                    response_text += content
-                                    live.update(display_generating(response_text, start_time))
-                    else:
-                        # Non-verbose mode, just collect the response
-                        response_text = ""
-                        for chunk in litellm.completion(
-                            model=self.model,
-                            messages=messages,
-                            temperature=temperature,
-                            stream=True,
-                            **kwargs
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                response_text += chunk.choices[0].delta.content
+                                    response_text += chunk.choices[0].delta.content
 
-                    response_text = response_text.strip()
+                        response_text = response_text.strip()
 
                     # Get final completion to check for tool calls
                     final_response = litellm.completion(
@@ -302,9 +337,53 @@ class LLM:
                                     "content": "Function returned an empty output"
                                 })
 
-                        # Get response after tool calls with streaming
-                        if verbose:
-                            with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                        # If reasoning_steps is True, do a single non-streaming call
+                        if reasoning_steps:
+                            resp = litellm.completion(
+                                model=self.model,
+                                messages=messages,
+                                temperature=temperature,
+                                stream=False,  # force non-streaming
+                                **kwargs
+                            )
+                            reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                            response_text = resp["choices"][0]["message"]["content"]
+                            
+                            # Optionally display reasoning if present
+                            if verbose and reasoning_content:
+                                display_interaction(
+                                    original_prompt,
+                                    f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
+                                    markdown=markdown,
+                                    generation_time=time.time() - start_time,
+                                    console=console
+                                )
+                            else:
+                                display_interaction(
+                                    original_prompt,
+                                    response_text,
+                                    markdown=markdown,
+                                    generation_time=time.time() - start_time,
+                                    console=console
+                                )
+                        
+                        # Otherwise do the existing streaming approach
+                        else:
+                            # Get response after tool calls with streaming
+                            if verbose:
+                                with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                                    response_text = ""
+                                    for chunk in litellm.completion(
+                                        model=self.model,
+                                        messages=messages,
+                                        temperature=temperature,
+                                        stream=True
+                                    ):
+                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                            content = chunk.choices[0].delta.content
+                                            response_text += content
+                                            live.update(display_generating(response_text, start_time))
+                            else:
                                 response_text = ""
                                 for chunk in litellm.completion(
                                     model=self.model,
@@ -313,21 +392,9 @@ class LLM:
                                     stream=True
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                        content = chunk.choices[0].delta.content
-                                        response_text += content
-                                        live.update(display_generating(response_text, start_time))
-                        else:
-                            response_text = ""
-                            for chunk in litellm.completion(
-                                model=self.model,
-                                messages=messages,
-                                temperature=temperature,
-                                stream=True
-                            ):
-                                if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    response_text += chunk.choices[0].delta.content
+                                        response_text += chunk.choices[0].delta.content
 
-                        response_text = response_text.strip()
+                            response_text = response_text.strip()
 
                     # Handle output formatting
                     if output_json or output_pydantic:
@@ -342,6 +409,9 @@ class LLM:
                         if verbose:
                             display_interaction(original_prompt, response_text, markdown=markdown,
                                              generation_time=time.time() - start_time, console=console)
+                        # Return reasoning content if reasoning_steps is True
+                        if reasoning_steps and reasoning_content:
+                            return reasoning_content
                         return response_text
 
                     # Handle self-reflection
@@ -357,32 +427,66 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         {"role": "user", "content": reflection_prompt}
                     ]
 
-                    # Get reflection response with streaming
-                    if verbose:
-                        with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                    # If reasoning_steps is True, do a single non-streaming call to capture reasoning
+                    if reasoning_steps:
+                        reflection_resp = litellm.completion(
+                            model=self.model,
+                            messages=reflection_messages,
+                            temperature=temperature,
+                            stream=False,  # Force non-streaming
+                            response_format={"type": "json_object"},
+                            **kwargs
+                        )
+                        # Grab reflection text and optional reasoning
+                        reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                        reflection_text = reflection_resp["choices"][0]["message"]["content"]
+
+                        # Optionally display reasoning if present
+                        if verbose and reasoning_content:
+                            display_interaction(
+                                "Reflection reasoning:",
+                                f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                        elif verbose:
+                            display_interaction(
+                                "Self-reflection (non-streaming):",
+                                reflection_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                    else:
+                        # Existing streaming approach
+                        if verbose:
+                            with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                                reflection_text = ""
+                                for chunk in litellm.completion(
+                                    model=self.model,
+                                    messages=reflection_messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    response_format={"type": "json_object"},
+                                    **kwargs
+                                ):
+                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                        content = chunk.choices[0].delta.content
+                                        reflection_text += content
+                                        live.update(display_generating(reflection_text, start_time))
+                        else:
                             reflection_text = ""
                             for chunk in litellm.completion(
                                 model=self.model,
                                 messages=reflection_messages,
                                 temperature=temperature,
                                 stream=True,
-                                response_format={"type": "json_object"}
+                                response_format={"type": "json_object"},
+                                **kwargs
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    content = chunk.choices[0].delta.content
-                                    reflection_text += content
-                                    live.update(display_generating(reflection_text, start_time))
-                    else:
-                        reflection_text = ""
-                        for chunk in litellm.completion(
-                            model=self.model,
-                            messages=reflection_messages,
-                            temperature=temperature,
-                            stream=True,
-                            response_format={"type": "json_object"}
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                reflection_text += chunk.choices[0].delta.content
+                                    reflection_text += chunk.choices[0].delta.content
 
                     try:
                         reflection_data = json.loads(reflection_text)
@@ -453,6 +557,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         """Async version of get_response with identical functionality."""
         try:
             import litellm
+            reasoning_steps = kwargs.get('reasoning_steps', self.reasoning_steps)
             litellm.set_verbose = False
 
             # Build messages list
@@ -490,10 +595,10 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # Format tools for LiteLLM
             formatted_tools = None
             if tools:
-                logging.info(f"Starting tool formatting for {len(tools)} tools")
+                logging.debug(f"Starting tool formatting for {len(tools)} tools")
                 formatted_tools = []
                 for tool in tools:
-                    logging.info(f"Processing tool: {tool.__name__ if hasattr(tool, '__name__') else str(tool)}")
+                    logging.debug(f"Processing tool: {tool.__name__ if hasattr(tool, '__name__') else str(tool)}")
                     if hasattr(tool, '__name__'):
                         tool_name = tool.__name__
                         tool_doc = tool.__doc__ or "No description available"
@@ -539,10 +644,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             }
                         }
                         # Ensure tool definition is JSON serializable
-                        print(f"Generated tool definition: {tool_def}")
                         try:
                             json.dumps(tool_def)  # Test serialization
-                            logging.info(f"Generated tool definition: {tool_def}")
+                            logging.debug(f"Generated tool definition: {tool_def}")
                             formatted_tools.append(tool_def)
                         except TypeError as e:
                             logging.error(f"Tool definition not JSON serializable: {e}")
@@ -552,38 +656,67 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             if formatted_tools:
                 try:
                     json.dumps(formatted_tools)  # Final serialization check
-                    logging.info(f"Final formatted tools: {json.dumps(formatted_tools, indent=2)}")
+                    logging.debug(f"Final formatted tools: {json.dumps(formatted_tools, indent=2)}")
                 except TypeError as e:
                     logging.error(f"Final tools list not JSON serializable: {e}")
                     formatted_tools = None
 
             response_text = ""
-            if verbose:
-                # ----------------------------------------------------
-                # 1) Make the streaming call WITHOUT tools
-                # ----------------------------------------------------
-                async for chunk in await litellm.acompletion(
+            if reasoning_steps:
+                # Non-streaming call to capture reasoning
+                resp = await litellm.acompletion(
                     model=self.model,
                     messages=messages,
                     temperature=temperature,
-                    stream=True,
+                    stream=False,  # force non-streaming
                     **kwargs
-                ):
-                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                        response_text += chunk.choices[0].delta.content
-                        print("\033[K", end="\r")  
-                        print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
+                )
+                reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                response_text = resp["choices"][0]["message"]["content"]
+                
+                if verbose and reasoning_content:
+                    display_interaction(
+                        "Initial reasoning:",
+                        f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
+                elif verbose:
+                    display_interaction(
+                        "Initial response:",
+                        response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
             else:
-                # Non-verbose streaming call, still no tools
-                async for chunk in await litellm.acompletion(
-                    model=self.model,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=True,
-                    **kwargs
-                ):
-                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                        response_text += chunk.choices[0].delta.content
+                if verbose:
+                    # ----------------------------------------------------
+                    # 1) Make the streaming call WITHOUT tools
+                    # ----------------------------------------------------
+                    async for chunk in await litellm.acompletion(
+                        model=self.model,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=True,
+                        **kwargs
+                    ):
+                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                            response_text += chunk.choices[0].delta.content
+                            print("\033[K", end="\r")  
+                            print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
+                else:
+                    # Non-verbose streaming call, still no tools
+                    async for chunk in await litellm.acompletion(
+                        model=self.model,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=True,
+                        **kwargs
+                    ):
+                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                            response_text += chunk.choices[0].delta.content
 
             response_text = response_text.strip()
 
@@ -634,35 +767,66 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 "content": "Function returned an empty output"
                             })
 
-                    # Get response after tool calls with streaming
+                    # Get response after tool calls
                     response_text = ""
-                    if verbose:
-                        async for chunk in await litellm.acompletion(
+                    if reasoning_steps:
+                        # Non-streaming call to capture reasoning
+                        resp = await litellm.acompletion(
                             model=self.model,
                             messages=messages,
                             temperature=temperature,
-                            stream=True,
-                            tools=formatted_tools,
+                            stream=False,  # force non-streaming
+                            tools=formatted_tools,  # Include tools
                             **kwargs
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                content = chunk.choices[0].delta.content
-                                response_text += content
-                                print("\033[K", end="\r")
-                                print(f"Reflecting... {time.time() - start_time:.1f}s", end="\r")
-            else:
-                response_text = ""
-                for chunk in litellm.completion(
-                    model=self.model,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=True,
-                    **kwargs
-                ):
-                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                        response_text += chunk.choices[0].delta.content
+                        )
+                        reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                        response_text = resp["choices"][0]["message"]["content"]
+                        
+                        if verbose and reasoning_content:
+                            display_interaction(
+                                "Tool response reasoning:",
+                                f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                        elif verbose:
+                            display_interaction(
+                                "Tool response:",
+                                response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                    else:
+                        # Get response after tool calls with streaming
+                        if verbose:
+                            async for chunk in await litellm.acompletion(
+                                model=self.model,
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                tools=formatted_tools,
+                                **kwargs
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                    content = chunk.choices[0].delta.content
+                                    response_text += content
+                                    print("\033[K", end="\r")
+                                    print(f"Reflecting... {time.time() - start_time:.1f}s", end="\r")
+                        else:
+                            response_text = ""
+                            for chunk in litellm.completion(
+                                model=self.model,
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                **kwargs
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                    response_text += chunk.choices[0].delta.content
 
-            response_text = response_text.strip()
+                    response_text = response_text.strip()
 
             # Handle output formatting
             if output_json or output_pydantic:
@@ -677,6 +841,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 if verbose:
                     display_interaction(original_prompt, response_text, markdown=markdown,
                                      generation_time=time.time() - start_time, console=console)
+                # Return reasoning content if reasoning_steps is True
+                if reasoning_steps and reasoning_content:
+                    return reasoning_content
                 return response_text
 
             # Handle self-reflection
@@ -692,33 +859,66 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 {"role": "user", "content": reflection_prompt}
             ]
 
-            # Get reflection response
-            reflection_text = ""
-            if verbose:
-                async for chunk in await litellm.acompletion(
+            # If reasoning_steps is True, do a single non-streaming call to capture reasoning
+            if reasoning_steps:
+                reflection_resp = litellm.completion(
                     model=self.model,
                     messages=reflection_messages,
                     temperature=temperature,
-                    stream=True,
+                    stream=False,  # Force non-streaming
                     response_format={"type": "json_object"},
                     **kwargs
-                ):
-                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                        content = chunk.choices[0].delta.content
-                        reflection_text += content
-                        print("\033[K", end="\r")
-                        print(f"Reflecting... {time.time() - start_time:.1f}s", end="\r")
+                )
+                # Grab reflection text and optional reasoning
+                reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                reflection_text = reflection_resp["choices"][0]["message"]["content"]
+
+                # Optionally display reasoning if present
+                if verbose and reasoning_content:
+                    display_interaction(
+                        "Reflection reasoning:",
+                        f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
+                elif verbose:
+                    display_interaction(
+                        "Self-reflection (non-streaming):",
+                        reflection_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
             else:
-                async for chunk in await litellm.acompletion(
-                    model=self.model,
-                    messages=reflection_messages,
-                    temperature=temperature,
-                    stream=True,
-                    response_format={"type": "json_object"},
-                    **kwargs
-                ):
-                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                        reflection_text += chunk.choices[0].delta.content
+                # Existing streaming approach
+                if verbose:
+                    with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                        reflection_text = ""
+                        for chunk in litellm.completion(
+                            model=self.model,
+                            messages=reflection_messages,
+                            temperature=temperature,
+                            stream=True,
+                            response_format={"type": "json_object"},
+                            **kwargs
+                        ):
+                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                content = chunk.choices[0].delta.content
+                                reflection_text += content
+                                live.update(display_generating(reflection_text, start_time))
+                else:
+                    reflection_text = ""
+                    for chunk in litellm.completion(
+                        model=self.model,
+                        messages=reflection_messages,
+                        temperature=temperature,
+                        stream=True,
+                        response_format={"type": "json_object"},
+                        **kwargs
+                    ):
+                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                            reflection_text += chunk.choices[0].delta.content
 
             while True:  # Add loop for reflection handling
                 try:

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/praisonaiagents/task/task.py

@@ -302,4 +302,21 @@ Expected Output: {self.expected_output}.
 Context:
 
 {'  '.join(unique_contexts)}
-"""
+"""
+
+    def execute_callback_sync(self, task_output: TaskOutput) -> None:
+        """
+        Synchronous wrapper to ensure that execute_callback is awaited,
+        preventing 'Task was destroyed but pending!' warnings if called 
+        from non-async code.
+        """
+        import asyncio
+        try:
+            loop = asyncio.get_running_loop()
+            if loop.is_running():
+                loop.create_task(self.execute_callback(task_output))
+            else:
+                loop.run_until_complete(self.execute_callback(task_output))
+        except RuntimeError:
+            # If no loop is running in this context
+            asyncio.run(self.execute_callback(task_output))

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.51
+Version: 0.0.53
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.51 → praisonaiagents-0.0.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.51"
+version = "0.0.53"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }