praisonaiagents 0.0.52__py3-none-any.whl → 0.0.54__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -318,7 +318,7 @@ class Agent:
         min_reflect: int = 1,
         reflect_llm: Optional[str] = None,
         user_id: Optional[str] = None,
-        show_reasoning: bool = False
+        reasoning_steps: bool = False
     ):
         # Add check at start if memory is requested
         if memory is not None:
@@ -426,7 +426,7 @@ Your Goal: {self.goal}
 
         # Store user_id
         self.user_id = user_id or "praison"
-        self.show_reasoning = show_reasoning
+        self.reasoning_steps = reasoning_steps
 
         # Check if knowledge parameter has any values
         if not knowledge:
@@ -528,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}")
 
@@ -617,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
@@ -644,8 +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):
-        show_reasoning = show_reasoning or self.show_reasoning
+    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)
@@ -682,7 +682,7 @@ Your Goal: {self.goal}
                     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
-                    show_reasoning=show_reasoning
+                    reasoning_steps=reasoning_steps
                 )
 
                 self.chat_history.append({"role": "user", "content": prompt})
@@ -752,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
 
@@ -811,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"""
@@ -885,9 +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.""" 
-        show_reasoning = show_reasoning or self.show_reasoning
+        reasoning_steps = reasoning_steps or self.reasoning_steps
         try:
             # Search for existing knowledge if any knowledge is provided
             if self.knowledge:
@@ -919,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})
@@ -985,48 +988,48 @@ Your Goal: {self.goal}
                             )
 
                     # Format tools if provided
-                        formatted_tools = []
-                        if tools:
-                            for tool in tools:
-                                if isinstance(tool, str):
-                                    tool_def = self._generate_tool_definition(tool)
-                                    if tool_def:
-                                        formatted_tools.append(tool_def)
-                                elif isinstance(tool, dict):
-                                    formatted_tools.append(tool)
-                                elif hasattr(tool, "to_openai_tool"):
-                                    formatted_tools.append(tool.to_openai_tool())
-                                elif callable(tool):
-                                    formatted_tools.append(self._generate_tool_definition(tool.__name__))
-
-                        # Create async OpenAI client
-                        async_client = AsyncOpenAI()
-
-                        # Make the API call based on the type of request
-                        if tools:
-                            response = await async_client.chat.completions.create(
-                                model=self.llm,
-                                messages=messages,
-                                temperature=temperature,
-                                tools=formatted_tools
-                            )
-                            return await self._achat_completion(response, tools)
-                        elif output_json or output_pydantic:
-                            response = await async_client.chat.completions.create(
-                                model=self.llm,
-                                messages=messages,
-                                temperature=temperature,
-                                response_format={"type": "json_object"}
-                            )
-                            # Return the raw response
-                            return response.choices[0].message.content
-                        else:
-                            response = await async_client.chat.completions.create(
-                                model=self.llm,
-                                messages=messages,
-                                temperature=temperature
-                            )
-                            return response.choices[0].message.content
+                    formatted_tools = []
+                    if tools:
+                        for tool in tools:
+                            if isinstance(tool, str):
+                                tool_def = self._generate_tool_definition(tool)
+                                if tool_def:
+                                    formatted_tools.append(tool_def)
+                            elif isinstance(tool, dict):
+                                formatted_tools.append(tool)
+                            elif hasattr(tool, "to_openai_tool"):
+                                formatted_tools.append(tool.to_openai_tool())
+                            elif callable(tool):
+                                formatted_tools.append(self._generate_tool_definition(tool.__name__))
+
+                    # Create async OpenAI client
+                    async_client = AsyncOpenAI()
+
+                    # Make the API call based on the type of request
+                    if tools:
+                        response = await async_client.chat.completions.create(
+                            model=self.llm,
+                            messages=messages,
+                            temperature=temperature,
+                            tools=formatted_tools
+                        )
+                        return await self._achat_completion(response, tools)
+                    elif output_json or output_pydantic:
+                        response = await async_client.chat.completions.create(
+                            model=self.llm,
+                            messages=messages,
+                            temperature=temperature,
+                            response_format={"type": "json_object"}
+                        )
+                        # Return the raw response
+                        return response.choices[0].message.content
+                    else:
+                        response = await async_client.chat.completions.create(
+                            model=self.llm,
+                            messages=messages,
+                            temperature=temperature
+                        )
+                        return response.choices[0].message.content
                 except Exception as e:
                     display_error(f"Error in chat completion: {e}")
                     return None
@@ -1034,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
@@ -1102,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
@@ -1111,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/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/llm/llm.py

@@ -148,7 +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.show_reasoning = extra_settings.get('show_reasoning', False)
+        self.reasoning_steps = extra_settings.get('reasoning_steps', False)
         
         # Enable error dropping for cleaner output
         litellm.drop_params = True
@@ -178,7 +178,8 @@ class LLM:
         """Enhanced get_response with all OpenAI-like features"""
         try:
             import litellm
-            show_reasoning = kwargs.get('show_reasoning', self.show_reasoning)
+            # This below **kwargs** is passed to .completion() directly. so reasoning_steps has to be popped. OR find alternate best way of handling this.
+            reasoning_steps = kwargs.pop('reasoning_steps', self.reasoning_steps) 
             # Disable litellm debug messages
             litellm.set_verbose = False
             
@@ -233,14 +234,14 @@ class LLM:
                     # Get response from LiteLLM
                     start_time = time.time()
 
-                    # If show_reasoning is True, do a single non-streaming call
-                    if show_reasoning:
+                    # 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
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         )
                         reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
                         response_text = resp["choices"][0]["message"]["content"]
@@ -337,14 +338,14 @@ class LLM:
                                     "content": "Function returned an empty output"
                                 })
 
-                        # If show_reasoning is True, do a single non-streaming call
-                        if show_reasoning:
+                        # 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
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                             )
                             reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
                             response_text = resp["choices"][0]["message"]["content"]
@@ -409,6 +410,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
@@ -424,15 +428,15 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         {"role": "user", "content": reflection_prompt}
                     ]
 
-                    # If show_reasoning is True, do a single non-streaming call to capture reasoning
-                    if show_reasoning:
+                    # 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
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         )
                         # Grab reflection text and optional reasoning
                         reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
@@ -466,7 +470,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     temperature=temperature,
                                     stream=True,
                                     response_format={"type": "json_object"},
-                                    **kwargs
+                                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
                                         content = chunk.choices[0].delta.content
@@ -480,7 +484,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 temperature=temperature,
                                 stream=True,
                                 response_format={"type": "json_object"},
-                                **kwargs
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                     reflection_text += chunk.choices[0].delta.content
@@ -554,7 +558,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         """Async version of get_response with identical functionality."""
         try:
             import litellm
-            show_reasoning = kwargs.get('show_reasoning', self.show_reasoning)
+            reasoning_steps = kwargs.pop('reasoning_steps', self.reasoning_steps)
             litellm.set_verbose = False
 
             # Build messages list
@@ -659,14 +663,14 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     formatted_tools = None
 
             response_text = ""
-            if show_reasoning:
+            if reasoning_steps:
                 # Non-streaming call to capture reasoning
                 resp = await litellm.acompletion(
                     model=self.model,
                     messages=messages,
                     temperature=temperature,
                     stream=False,  # force non-streaming
-                    **kwargs
+                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                 )
                 reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
                 response_text = resp["choices"][0]["message"]["content"]
@@ -728,7 +732,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     temperature=temperature,
                     stream=False,
                     tools=formatted_tools,  # We safely pass tools here
-                    **kwargs
+                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                 )
                 # handle tool_calls from tool_response as usual...
                 tool_calls = tool_response.choices[0].message.get("tool_calls")
@@ -766,7 +770,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
                     # Get response after tool calls
                     response_text = ""
-                    if show_reasoning:
+                    if reasoning_steps:
                         # Non-streaming call to capture reasoning
                         resp = await litellm.acompletion(
                             model=self.model,
@@ -774,7 +778,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             temperature=temperature,
                             stream=False,  # force non-streaming
                             tools=formatted_tools,  # Include tools
-                            **kwargs
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         )
                         reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
                         response_text = resp["choices"][0]["message"]["content"]
@@ -804,7 +808,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 temperature=temperature,
                                 stream=True,
                                 tools=formatted_tools,
-                                **kwargs
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                     content = chunk.choices[0].delta.content
@@ -818,7 +822,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 messages=messages,
                                 temperature=temperature,
                                 stream=True,
-                                **kwargs
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                     response_text += chunk.choices[0].delta.content
@@ -838,6 +842,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
@@ -853,15 +860,15 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 {"role": "user", "content": reflection_prompt}
             ]
 
-            # If show_reasoning is True, do a single non-streaming call to capture reasoning
-            if show_reasoning:
+            # 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
+                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                 )
                 # Grab reflection text and optional reasoning
                 reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
@@ -895,7 +902,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             temperature=temperature,
                             stream=True,
                             response_format={"type": "json_object"},
-                            **kwargs
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         ):
                             if chunk and chunk.choices and chunk.choices[0].delta.content:
                                 content = chunk.choices[0].delta.content
@@ -909,7 +916,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         temperature=temperature,
                         stream=True,
                         response_format={"type": "json_object"},
-                        **kwargs
+                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                     ):
                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                             reflection_text += chunk.choices[0].delta.content

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.52.dist-info → praisonaiagents-0.0.54.dist-info}/METADATA

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

{praisonaiagents-0.0.52.dist-info → praisonaiagents-0.0.54.dist-info}/RECORD

@@ -1,20 +1,20 @@
 praisonaiagents/__init__.py,sha256=JtPibbmeFv3meIb3vkKjckB0p7m-Vqt2RYPwOH8P41k,1228
 praisonaiagents/main.py,sha256=0kB9gn9meXtr4EIrdgA2lAioKIHCRJ61audsGDwuTm4,14428
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=9r9eN9sTI3A_3IZdA4GYpsKXE5Q4m8yQ_QXGyFirQok,53844
+praisonaiagents/agent/agent.py,sha256=Rd2ZCToraAoe57UDT1JfrB03ffRKtZ-Tct9avFcZyT4,54257
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=PRqBEUqRadVLBoDd-tgne5fVB87bR6P9qOgvDdjS-dY,37028
+praisonaiagents/agents/agents.py,sha256=94YPQl-hl-EPY6-Xk2Rj9wlIs9YtiLQbsutSOXWX8QI,36156
 praisonaiagents/agents/autoagents.py,sha256=bjC2O5oZmoJItJXIMPTWc2lsp_AJC9tMiTQOal2hwPA,13532
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=WEfqWEOb2Sa2V5MRVa2XbFCBcrE5WBMeEhSFq3HCZvM,49145
+praisonaiagents/llm/llm.py,sha256=M6xh9cuO0KZjzpAkHZrnktxw4eCmXLymoZqMoXeq-0U,50352
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=_1Nk37kOYakPaUWAJff86rP0ENyykXqMnhTp8E0efuE,30802
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=YKoUOyIBQflOSCO4nuSi6sL-s2-Awujjs44qNqiUETI,13582
+praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
 praisonaiagents/tools/__init__.py,sha256=-0lV5n5cG54vYW6REjXIfuJnCLKnfQIDlXsySCaPB9s,7347
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
@@ -35,7 +35,7 @@ praisonaiagents/tools/wikipedia_tools.py,sha256=pGko-f33wqXgxJTv8db7TbizY5XnzBQR
 praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxNMMs1A,17122
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
-praisonaiagents-0.0.52.dist-info/METADATA,sha256=NIkU1FNQXms13nIStb4r2yYjItL1aA0XSL7sCy1HxMM,830
-praisonaiagents-0.0.52.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.52.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.52.dist-info/RECORD,,
+praisonaiagents-0.0.54.dist-info/METADATA,sha256=Zfzek1Y53OzW35U-lLAX5mTpdS0xxV57mCDdHhcSfYo,830
+praisonaiagents-0.0.54.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.54.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.54.dist-info/RECORD,,