praisonaiagents 0.0.91__py3-none-any.whl → 0.0.93__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -864,7 +864,11 @@ Your Goal: {self.goal}
         if self._using_custom_llm:
             try:
                 # Special handling for MCP tools when using provider/model format
-                tool_param = self.tools if tools is None else tools
+                # Fix: Handle empty tools list properly - use self.tools if tools is None or empty
+                if tools is None or (isinstance(tools, list) and len(tools) == 0):
+                    tool_param = self.tools
+                else:
+                    tool_param = tools
                 
                 # Convert MCP tool objects to OpenAI format if needed
                 if tool_param is not None:

praisonaiagents/agents/agents.py

@@ -443,12 +443,12 @@ Context:
                     if task.callback:
                         try:
                             if asyncio.iscoroutinefunction(task.callback):
-                                if asyncio.get_event_loop().is_running():
-                                    asyncio.create_task(task.callback(task_output))
-                                else:
-                                    loop = asyncio.new_event_loop()
-                                    asyncio.set_event_loop(loop)
-                                    loop.run_until_complete(task.callback(task_output))
+                                try:
+                                    loop = asyncio.get_running_loop()
+                                    loop.create_task(task.callback(task_output))
+                                except RuntimeError:
+                                    # No event loop running, create new one
+                                    asyncio.run(task.callback(task_output))
                             else:
                                 task.callback(task_output)
                         except Exception as e:
@@ -765,12 +765,12 @@ Context:
                     if task.callback:
                         try:
                             if asyncio.iscoroutinefunction(task.callback):
-                                if asyncio.get_event_loop().is_running():
-                                    asyncio.create_task(task.callback(task_output))
-                                else:
-                                    loop = asyncio.new_event_loop()
-                                    asyncio.set_event_loop(loop)
-                                    loop.run_until_complete(task.callback(task_output))
+                                try:
+                                    loop = asyncio.get_running_loop()
+                                    loop.create_task(task.callback(task_output))
+                                except RuntimeError:
+                                    # No event loop running, create new one
+                                    asyncio.run(task.callback(task_output))
                             else:
                                 task.callback(task_output)
                         except Exception as e:

praisonaiagents/llm/llm.py

@@ -205,6 +205,72 @@ class LLM:
             }
             logging.debug(f"LLM instance initialized with: {json.dumps(debug_info, indent=2, default=str)}")
 
+    def _is_ollama_provider(self) -> bool:
+        """Detect if this is an Ollama provider regardless of naming convention"""
+        if not self.model:
+            return False
+        
+        # Direct ollama/ prefix
+        if self.model.startswith("ollama/"):
+            return True
+            
+        # Check environment variables for Ollama base URL
+        base_url = os.getenv("OPENAI_BASE_URL", "")
+        api_base = os.getenv("OPENAI_API_BASE", "")
+        
+        # Common Ollama endpoints
+        ollama_endpoints = ["localhost:11434", "127.0.0.1:11434", ":11434"]
+        
+        return any(endpoint in base_url or endpoint in api_base for endpoint in ollama_endpoints)
+
+    def _parse_tool_call_arguments(self, tool_call: Dict, is_ollama: bool = False) -> tuple:
+        """
+        Safely parse tool call arguments with proper error handling
+        
+        Returns:
+            tuple: (function_name, arguments, tool_call_id)
+        """
+        try:
+            if is_ollama:
+                # Special handling for Ollama provider which may have different structure
+                if "function" in tool_call and isinstance(tool_call["function"], dict):
+                    function_name = tool_call["function"]["name"]
+                    arguments = json.loads(tool_call["function"]["arguments"])
+                else:
+                    # Try alternative format that Ollama might return
+                    function_name = tool_call.get("name", "unknown_function")
+                    arguments_str = tool_call.get("arguments", "{}")
+                    arguments = json.loads(arguments_str) if arguments_str else {}
+                tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
+            else:
+                # Standard format for other providers with error handling
+                function_name = tool_call["function"]["name"]
+                arguments_str = tool_call["function"]["arguments"]
+                arguments = json.loads(arguments_str) if arguments_str else {}
+                tool_call_id = tool_call["id"]
+                
+        except (KeyError, json.JSONDecodeError, TypeError) as e:
+            logging.error(f"Error parsing tool call arguments: {e}")
+            function_name = tool_call.get("name", "unknown_function")
+            arguments = {}
+            tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
+            
+        return function_name, arguments, tool_call_id
+
+    def _needs_system_message_skip(self) -> bool:
+        """Check if this model requires skipping system messages"""
+        if not self.model:
+            return False
+        
+        # Only skip for specific legacy o1 models that don't support system messages
+        legacy_o1_models = [
+            "o1-preview",           # 2024-09-12 version
+            "o1-mini",              # 2024-09-12 version  
+            "o1-mini-2024-09-12"    # Explicit dated version
+        ]
+        
+        return self.model in legacy_o1_models
+
     def get_response(
         self,
         prompt: Union[str, List[Dict]],
@@ -320,7 +386,9 @@ class LLM:
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
                 elif output_pydantic:
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             if chat_history:
                 messages.extend(chat_history)
@@ -470,32 +538,19 @@ class LLM:
                         for tool_call in tool_calls:
                             # Handle both object and dict access patterns
                             if isinstance(tool_call, dict):
-                                # Special handling for Ollama provider which may have a different structure
-                                if self.model and self.model.startswith("ollama/"):
-                                    try:
-                                        # Try standard format first
-                                        if "function" in tool_call and isinstance(tool_call["function"], dict):
-                                            function_name = tool_call["function"]["name"]
-                                            arguments = json.loads(tool_call["function"]["arguments"])
-                                        else:
-                                            # Try alternative format that Ollama might return
-                                            function_name = tool_call.get("name", "unknown_function")
-                                            arguments = json.loads(tool_call.get("arguments", "{}"))
-                                        tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
-                                    except Exception as e:
-                                        logging.error(f"Error processing Ollama tool call: {e}")
-                                        function_name = "unknown_function"
-                                        arguments = {}
-                                        tool_call_id = f"tool_{id(tool_call)}"
-                                else:
-                                    # Standard format for other providers
-                                    function_name = tool_call["function"]["name"]
-                                    arguments = json.loads(tool_call["function"]["arguments"])
-                                    tool_call_id = tool_call["id"]
+                                is_ollama = self._is_ollama_provider()
+                                function_name, arguments, tool_call_id = self._parse_tool_call_arguments(tool_call, is_ollama)
                             else:
-                                function_name = tool_call.function.name
-                                arguments = json.loads(tool_call.function.arguments)
-                                tool_call_id = tool_call.id
+                                # Handle object-style tool calls
+                                try:
+                                    function_name = tool_call.function.name
+                                    arguments = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
+                                    tool_call_id = tool_call.id
+                                except (json.JSONDecodeError, AttributeError) as e:
+                                    logging.error(f"Error parsing object-style tool call: {e}")
+                                    function_name = "unknown_function"
+                                    arguments = {}
+                                    tool_call_id = f"tool_{id(tool_call)}"
 
                             logging.debug(f"[TOOL_EXEC_DEBUG] About to execute tool {function_name} with args: {arguments}")
                             tool_result = execute_tool_fn(function_name, arguments)
@@ -867,7 +922,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
                 elif output_pydantic:
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             if chat_history:
                 messages.extend(chat_history)
@@ -1065,32 +1122,19 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     for tool_call in tool_calls:
                         # Handle both object and dict access patterns
                         if isinstance(tool_call, dict):
-                            # Special handling for Ollama provider which may have a different structure
-                            if self.model and self.model.startswith("ollama/"):
-                                try:
-                                    # Try standard format first
-                                    if "function" in tool_call and isinstance(tool_call["function"], dict):
-                                        function_name = tool_call["function"]["name"]
-                                        arguments = json.loads(tool_call["function"]["arguments"])
-                                    else:
-                                        # Try alternative format that Ollama might return
-                                        function_name = tool_call.get("name", "unknown_function")
-                                        arguments = json.loads(tool_call.get("arguments", "{}"))
-                                    tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
-                                except Exception as e:
-                                    logging.error(f"Error processing Ollama tool call: {e}")
-                                    function_name = "unknown_function"
-                                    arguments = {}
-                                    tool_call_id = f"tool_{id(tool_call)}"
-                            else:
-                                # Standard format for other providers
-                                function_name = tool_call["function"]["name"]
-                                arguments = json.loads(tool_call["function"]["arguments"])
-                                tool_call_id = tool_call["id"]
+                            is_ollama = self._is_ollama_provider()
+                            function_name, arguments, tool_call_id = self._parse_tool_call_arguments(tool_call, is_ollama)
                         else:
-                            function_name = tool_call.function.name
-                            arguments = json.loads(tool_call.function.arguments)
-                            tool_call_id = tool_call.id
+                            # Handle object-style tool calls
+                            try:
+                                function_name = tool_call.function.name
+                                arguments = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
+                                tool_call_id = tool_call.id
+                            except (json.JSONDecodeError, AttributeError) as e:
+                                logging.error(f"Error parsing object-style tool call: {e}")
+                                function_name = "unknown_function"
+                                arguments = {}
+                                tool_call_id = f"tool_{id(tool_call)}"
 
                         tool_result = await execute_tool_fn(function_name, arguments)
 
@@ -1111,7 +1155,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     response_text = ""
                     
                     # Special handling for Ollama models that don't automatically process tool results
-                    if self.model and self.model.startswith("ollama/") and tool_result:
+                    if self._is_ollama_provider() and tool_result:
                         # For Ollama models, we need to explicitly ask the model to process the tool results
                         # First, check if the response is just a JSON tool call
                         try:
@@ -1517,7 +1561,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # Build messages list
             messages = []
             if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             # Add prompt to messages
             if isinstance(prompt, list):
@@ -1623,7 +1669,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # Build messages list
             messages = []
             if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             # Add prompt to messages
             if isinstance(prompt, list):

praisonaiagents/main.py

@@ -362,7 +362,24 @@ class ReflectionOutput(BaseModel):
     reflection: str
     satisfactory: Literal["yes", "no"]
 
-client = OpenAI(api_key=(os.environ["OPENAI_API_KEY"] if os.environ.get("OPENAI_API_KEY") else "xxxx"))
+# Constants
+LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
+
+# Initialize OpenAI client with proper API key handling
+api_key = os.environ.get("OPENAI_API_KEY")
+base_url = os.environ.get("OPENAI_API_BASE") or os.environ.get("OPENAI_BASE_URL")
+
+# For local servers like LM Studio, allow minimal API key
+if base_url and not api_key:
+    api_key = LOCAL_SERVER_API_KEY_PLACEHOLDER
+elif not api_key:
+    raise ValueError(
+        "OPENAI_API_KEY environment variable is required for the default OpenAI service. "
+        "If you are targeting a local server (e.g., LM Studio), ensure OPENAI_API_BASE is set "
+        f"(e.g., 'http://localhost:1234/v1') and you can use a placeholder API key by setting OPENAI_API_KEY='{LOCAL_SERVER_API_KEY_PLACEHOLDER}'"
+    )
+
+client = OpenAI(api_key=api_key, base_url=base_url)
 
 class TaskOutput(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)

praisonaiagents/process/process.py

@@ -1,5 +1,6 @@
 import logging
 import asyncio
+import json
 from typing import Dict, Optional, List, Any, AsyncGenerator
 from pydantic import BaseModel, ConfigDict
 from ..agent.agent import Agent
@@ -7,6 +8,7 @@ from ..task.task import Task
 from ..main import display_error, client
 import csv
 import os
+from openai import AsyncOpenAI
 
 class LoopItems(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -106,6 +108,128 @@ class Process:
                 logging.debug(f"Fallback attempt {fallback_attempts}: No 'not started' task found within retry limit.")
         return None # Return None if no task found after all attempts
 
+    async def _get_manager_instructions_with_fallback_async(self, manager_task, manager_prompt, ManagerInstructions):
+        """Async version of getting manager instructions with fallback"""
+        try:
+            # First try structured output (OpenAI compatible)
+            logging.info("Attempting structured output...")
+            return await self._get_structured_response_async(manager_task, manager_prompt, ManagerInstructions)
+        except Exception as e:
+            logging.info(f"Structured output failed: {e}, falling back to JSON mode...")
+            # Fallback to regular JSON mode
+            try:
+                # Generate JSON structure description from Pydantic model
+                try:
+                    schema = ManagerInstructions.model_json_schema()
+                    props_desc = ", ".join([f'"{k}": <{v.get("type", "any")}>' for k, v in schema.get('properties', {}).items()])
+                    required_props = schema.get('required', [])
+                    required_props_str = ', '.join(f'"{p}"' for p in required_props)
+                    required_desc = f" (required: {required_props_str})" if required_props else ""
+                    json_structure_desc = "{" + props_desc + "}"
+                    enhanced_prompt = manager_prompt + f"\n\nIMPORTANT: Respond with valid JSON only, using this exact structure: {json_structure_desc}{required_desc}"
+                except Exception as schema_error:
+                    logging.warning(f"Could not generate schema for ManagerInstructions: {schema_error}. Using hardcoded prompt.")
+                    # Fallback to hardcoded prompt if schema generation fails
+                    enhanced_prompt = manager_prompt + "\n\nIMPORTANT: Respond with valid JSON only, using this exact structure: {\"task_id\": <int>, \"agent_name\": \"<string>\", \"action\": \"<execute or stop>\"}"
+                
+                return await self._get_json_response_async(manager_task, enhanced_prompt, ManagerInstructions)
+            except Exception as fallback_error:
+                error_msg = f"Both structured output and JSON fallback failed: {fallback_error}"
+                logging.error(error_msg, exc_info=True)
+                raise Exception(error_msg) from fallback_error
+
+    def _get_manager_instructions_with_fallback(self, manager_task, manager_prompt, ManagerInstructions):
+        """Sync version of getting manager instructions with fallback"""
+        try:
+            # First try structured output (OpenAI compatible)
+            logging.info("Attempting structured output...")
+            manager_response = client.beta.chat.completions.parse(
+                model=self.manager_llm,
+                messages=[
+                    {"role": "system", "content": manager_task.description},
+                    {"role": "user", "content": manager_prompt}
+                ],
+                temperature=0.7,
+                response_format=ManagerInstructions
+            )
+            return manager_response.choices[0].message.parsed
+        except Exception as e:
+            logging.info(f"Structured output failed: {e}, falling back to JSON mode...")
+            # Fallback to regular JSON mode
+            try:
+                # Generate JSON structure description from Pydantic model
+                try:
+                    schema = ManagerInstructions.model_json_schema()
+                    props_desc = ", ".join([f'"{k}": <{v.get("type", "any")}>' for k, v in schema.get('properties', {}).items()])
+                    required_props = schema.get('required', [])
+                    required_props_str = ', '.join(f'"{p}"' for p in required_props)
+                    required_desc = f" (required: {required_props_str})" if required_props else ""
+                    json_structure_desc = "{" + props_desc + "}"
+                    enhanced_prompt = manager_prompt + f"\n\nIMPORTANT: Respond with valid JSON only, using this exact structure: {json_structure_desc}{required_desc}"
+                except Exception as schema_error:
+                    logging.warning(f"Could not generate schema for ManagerInstructions: {schema_error}. Using hardcoded prompt.")
+                    # Fallback to hardcoded prompt if schema generation fails
+                    enhanced_prompt = manager_prompt + "\n\nIMPORTANT: Respond with valid JSON only, using this exact structure: {\"task_id\": <int>, \"agent_name\": \"<string>\", \"action\": \"<execute or stop>\"}"
+                
+                manager_response = client.chat.completions.create(
+                    model=self.manager_llm,
+                    messages=[
+                        {"role": "system", "content": manager_task.description},
+                        {"role": "user", "content": enhanced_prompt}
+                    ],
+                    temperature=0.7,
+                    response_format={"type": "json_object"}
+                )
+                
+                # Parse JSON and validate with Pydantic
+                try:
+                    json_content = manager_response.choices[0].message.content
+                    parsed_json = json.loads(json_content)
+                    return ManagerInstructions(**parsed_json)
+                except (json.JSONDecodeError, ValueError) as e:
+                    raise Exception(f"Failed to parse JSON response: {json_content}") from e
+            except Exception as fallback_error:
+                error_msg = f"Both structured output and JSON fallback failed: {fallback_error}"
+                logging.error(error_msg, exc_info=True)
+                raise Exception(error_msg) from fallback_error
+
+    async def _get_structured_response_async(self, manager_task, manager_prompt, ManagerInstructions):
+        """Async version of structured response"""
+        # Create an async client instance for this async method
+        async_client = AsyncOpenAI()
+        manager_response = await async_client.beta.chat.completions.parse(
+            model=self.manager_llm,
+            messages=[
+                {"role": "system", "content": manager_task.description},
+                {"role": "user", "content": manager_prompt}
+            ],
+            temperature=0.7,
+            response_format=ManagerInstructions
+        )
+        return manager_response.choices[0].message.parsed
+
+    async def _get_json_response_async(self, manager_task, enhanced_prompt, ManagerInstructions):
+        """Async version of JSON fallback response"""
+        # Create an async client instance for this async method
+        async_client = AsyncOpenAI()
+        manager_response = await async_client.chat.completions.create(
+            model=self.manager_llm,
+            messages=[
+                {"role": "system", "content": manager_task.description},
+                {"role": "user", "content": enhanced_prompt}
+            ],
+            temperature=0.7,
+            response_format={"type": "json_object"}
+        )
+        
+        # Parse JSON and validate with Pydantic
+        try:
+            json_content = manager_response.choices[0].message.content
+            parsed_json = json.loads(json_content)
+            return ManagerInstructions(**parsed_json)
+        except (json.JSONDecodeError, ValueError) as e:
+            raise Exception(f"Failed to parse JSON response: {json_content}") from e
+
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
@@ -496,26 +620,13 @@ Provide a JSON with the structure:
             try:
                 logging.info("Requesting manager instructions...")
                 if manager_task.async_execution:
-                    manager_response = await client.beta.chat.completions.parse(
-                        model=self.manager_llm,
-                        messages=[
-                            {"role": "system", "content": manager_task.description},
-                            {"role": "user", "content": manager_prompt}
-                        ],
-                        temperature=0.7,
-                        response_format=ManagerInstructions
+                    parsed_instructions = await self._get_manager_instructions_with_fallback_async(
+                        manager_task, manager_prompt, ManagerInstructions
                     )
                 else:
-                    manager_response = client.beta.chat.completions.parse(
-                        model=self.manager_llm,
-                        messages=[
-                            {"role": "system", "content": manager_task.description},
-                            {"role": "user", "content": manager_prompt}
-                        ],
-                        temperature=0.7,
-                        response_format=ManagerInstructions
+                    parsed_instructions = self._get_manager_instructions_with_fallback(
+                        manager_task, manager_prompt, ManagerInstructions
                     )
-                parsed_instructions = manager_response.choices[0].message.parsed
                 logging.info(f"Manager instructions: {parsed_instructions}")
             except Exception as e:
                 display_error(f"Manager parse error: {e}")
@@ -1110,16 +1221,9 @@ Provide a JSON with the structure:
 
             try:
                 logging.info("Requesting manager instructions...")
-                manager_response = client.beta.chat.completions.parse(
-                    model=self.manager_llm,
-                    messages=[
-                        {"role": "system", "content": manager_task.description},
-                        {"role": "user", "content": manager_prompt}
-                    ],
-                    temperature=0.7,
-                    response_format=ManagerInstructions
+                parsed_instructions = self._get_manager_instructions_with_fallback(
+                    manager_task, manager_prompt, ManagerInstructions
                 )
-                parsed_instructions = manager_response.choices[0].message.parsed
                 logging.info(f"Manager instructions: {parsed_instructions}")
             except Exception as e:
                 display_error(f"Manager parse error: {e}")

praisonaiagents/task/task.py

@@ -47,11 +47,11 @@ class Task:
             try:
                 from ..memory.memory import Memory
                 MEMORY_AVAILABLE = True
-            except ImportError:
-                raise ImportError(
-                    "Memory features requested in Task but memory dependencies not installed. "
-                    "Please install with: pip install \"praisonaiagents[memory]\""
-                )
+            except ImportError as e:
+                logger.warning(f"Memory dependency missing: {e}")
+                logger.warning("Some memory features may not work. Install with: pip install \"praisonaiagents[memory]\"")
+                MEMORY_AVAILABLE = False
+                # Don't raise - let it continue with limited functionality
 
         self.input_file = input_file
         self.id = str(uuid.uuid4()) if id is None else str(id)

praisonaiagents/tools/__init__.py

@@ -7,6 +7,8 @@ TOOL_MAPPINGS = {
     # Direct functions
     'internet_search': ('.duckduckgo_tools', None),
     'duckduckgo': ('.duckduckgo_tools', None),
+    'searxng_search': ('.searxng_tools', None),
+    'searxng': ('.searxng_tools', None),
     
     # arXiv Tools
     'search_arxiv': ('.arxiv_tools', None),
@@ -171,7 +173,7 @@ def __getattr__(name: str) -> Any:
         # Direct function import
         module = import_module(module_path, __package__)
         if name in [
-            'duckduckgo', 'internet_search',
+            'duckduckgo', 'internet_search', 'searxng_search', 'searxng',
             'search_arxiv', 'get_arxiv_paper', 'get_papers_by_author', 'get_papers_by_category',
             'wiki_search', 'wiki_summary', 'wiki_page', 'wiki_random', 'wiki_language',
             'get_article', 'get_news_sources', 'get_articles_from_source', 'get_trending_topics',

{praisonaiagents-0.0.91.dist-info → praisonaiagents-0.0.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.91
+Version: 0.0.93
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.91.dist-info → praisonaiagents-0.0.93.dist-info}/RECORD

@@ -1,25 +1,25 @@
 praisonaiagents/__init__.py,sha256=Z2_rSA6mYozz0r3ioUgKzl3QV8uWRDS_QaqPg2oGjqg,1324
-praisonaiagents/main.py,sha256=EsMRCT1tYjHH7hgoXov5s1caIBeRkpIPK8EZQsMKlw4,15138
+praisonaiagents/main.py,sha256=D6XzpqdfglCQiWaH5LjRSv-bB3QkJso-i0h1uTFkPQI,15844
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
-praisonaiagents/agent/agent.py,sha256=-zENKxcaAWH5KJOed4KmcpAeBDNtRlxqG58QHdLH6RA,86334
+praisonaiagents/agent/agent.py,sha256=DPpTgobDVZw2qlPzvNS-Xi-OF3RlM2cil6y15cbXIy8,86553
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=lFWJDZeWQcr6RttV-pxvny-jfAM3UWiYjMnYo8pZYe0,59429
+praisonaiagents/agents/agents.py,sha256=-cWRgok0X_4Mk-L7dW6bFdX7JVpxfe7R6aLmukktwKc,59381
 praisonaiagents/agents/autoagents.py,sha256=Lc_b9mO2MeefBrsHkHoqFxEr5iRGrYuzDhslyybXwdw,13649
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=Po0JZsgjYJrXdNSggmUGOWidZEF0f8xo4nhsZZfh8tY,13217
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=Y8z7mfzL_OMhoPSIr7k7Demk8HvHmJZv80EXFY6SUEU,91863
+praisonaiagents/llm/llm.py,sha256=9wHmf0aGKf4a7YZ4JONmD7Ela8JBYVrkMFF2ei8Ivpk,93400
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=-U6md6zHoJZCWF8XFq921Yy5CcSNaGqvjg3aRT737LM,16765
 praisonaiagents/mcp/mcp_sse.py,sha256=DLh3F_aoVRM1X-7hgIOWOw4FQ1nGmn9YNbQTesykzn4,6792
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=7nGV-d9lDlQO6d7X4nMb7f6pMKCYNfoFzTrVvPrUefo,60179
+praisonaiagents/process/process.py,sha256=gxhMXG3s4CzaREyuwE5zxCMx2Wp_b_Wd53tDfkj8Qk8,66567
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=JShYyMkAC1_bhEt0s0CXwJtQFXY6bNu-rlb0mHyyoXM,15034
-praisonaiagents/tools/__init__.py,sha256=CWOYV9SudYY82r45LnNgaVRV3cmsAFdasNRkPrLsgmI,9198
+praisonaiagents/task/task.py,sha256=03Vcz3TaKIYnryFnKAuuQ7Ly5nTaxysFpem6sgn4gJA,15112
+praisonaiagents/tools/__init__.py,sha256=Rrgi7_3-yLHpfBB81WUi0-wD_wb_BsukwHVdjDYAF-0,9316
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
 praisonaiagents/tools/csv_tools.py,sha256=4Yr0QYwBXt-1BDXGLalB2eSsFR2mB5rH3KdHmRBQY6E,10036
@@ -40,7 +40,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.91.dist-info/METADATA,sha256=AVYx1DidbzoSBWeh23X-8LuX7gAEqOas0mCe90yVWQA,1273
-praisonaiagents-0.0.91.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.91.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.91.dist-info/RECORD,,
+praisonaiagents-0.0.93.dist-info/METADATA,sha256=HlnkZm2D8lKJPxXbT6ODUIbyzhJ1LMArMStjh1vCXlY,1273
+praisonaiagents-0.0.93.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.93.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.93.dist-info/RECORD,,