praisonaiagents 0.0.96__py3-none-any.whl → 0.0.98__py3-none-any.whl

praisonaiagents/session.py

@@ -0,0 +1,291 @@
+"""
+Session Management for PraisonAI Agents
+
+A simple wrapper around existing stateful capabilities to provide a unified
+session API for developers building stateful agent applications.
+"""
+
+import os
+import uuid
+from typing import Any, Dict, List, Optional
+from .agent import Agent
+from .memory import Memory
+from .knowledge import Knowledge
+
+
+class Session:
+    """
+    A simple wrapper around PraisonAI's existing stateful capabilities.
+    
+    Provides a unified API for:
+    - Session management with persistent state
+    - Memory operations (short-term, long-term, user-specific)
+    - Knowledge base operations
+    - Agent state management
+    
+    Example:
+        session = Session(session_id="chat_123", user_id="user_456")
+        
+        # Create stateful agent
+        agent = session.Agent(
+            name="Assistant", 
+            role="Helpful AI",
+            memory=True
+        )
+        
+        # Save session state
+        session.save_state({"conversation_topic": "AI research"})
+        
+        # Restore state later
+        session.restore_state()
+    """
+
+    def __init__(
+        self, 
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        memory_config: Optional[Dict[str, Any]] = None,
+        knowledge_config: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize a new session with optional persistence.
+        
+        Args:
+            session_id: Unique session identifier. Auto-generated if None.
+            user_id: User identifier for user-specific memory operations.
+            memory_config: Configuration for memory system (defaults to RAG)
+            knowledge_config: Configuration for knowledge base system
+        """
+        self.session_id = session_id or str(uuid.uuid4())[:8]
+        self.user_id = user_id or "default_user"
+
+        # Initialize memory with sensible defaults
+        default_memory_config = {
+            "provider": "rag",
+            "use_embedding": True,
+            "rag_db_path": f".praison/sessions/{self.session_id}/chroma_db"
+        }
+        if memory_config:
+            default_memory_config.update(memory_config)
+        self.memory_config = default_memory_config
+
+        # Initialize knowledge with session-specific config
+        default_knowledge_config = knowledge_config or {}
+        self.knowledge_config = default_knowledge_config
+
+        # Create session directory
+        os.makedirs(f".praison/sessions/{self.session_id}", exist_ok=True)
+
+        # Initialize components lazily
+        self._memory = None
+        self._knowledge = None
+        self._agents_instance = None
+
+    @property
+    def memory(self) -> Memory:
+        """Lazy-loaded memory instance"""
+        if self._memory is None:
+            self._memory = Memory(config=self.memory_config)
+        return self._memory
+
+    @property
+    def knowledge(self) -> Knowledge:
+        """Lazy-loaded knowledge instance"""
+        if self._knowledge is None:
+            self._knowledge = Knowledge(config=self.knowledge_config)
+        return self._knowledge
+
+    def Agent(
+        self,
+        name: str,
+        role: str = "Assistant", 
+        instructions: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
+        memory: bool = True,
+        knowledge: Optional[List[str]] = None,
+        **kwargs
+    ) -> Agent:
+        """
+        Create an agent with session context.
+        
+        Args:
+            name: Agent name
+            role: Agent role
+            instructions: Agent instructions
+            tools: List of tools for the agent
+            memory: Enable memory for the agent
+            knowledge: Knowledge sources for the agent
+            **kwargs: Additional agent parameters
+        
+        Returns:
+            Configured Agent instance
+        """
+        agent_kwargs = {
+            "name": name,
+            "role": role,
+            "user_id": self.user_id,
+            **kwargs
+        }
+
+        if instructions:
+            agent_kwargs["instructions"] = instructions
+        if tools:
+            agent_kwargs["tools"] = tools
+        if memory:
+            agent_kwargs["memory"] = self.memory
+        if knowledge:
+            agent_kwargs["knowledge"] = knowledge
+            agent_kwargs["knowledge_config"] = self.knowledge_config
+
+        return Agent(**agent_kwargs)
+
+    # Keep create_agent for backward compatibility
+    def create_agent(self, *args, **kwargs) -> Agent:
+        """Backward compatibility wrapper for Agent method"""
+        return self.Agent(*args, **kwargs)
+
+    def save_state(self, state_data: Dict[str, Any]) -> None:
+        """
+        Save session state data to memory.
+        
+        Args:
+            state_data: Dictionary of state data to save
+        """
+        state_text = f"Session state: {state_data}"
+        self.memory.store_short_term(
+            text=state_text,
+            metadata={
+                "type": "session_state",
+                "session_id": self.session_id,
+                "user_id": self.user_id,
+                **state_data
+            }
+        )
+
+    def restore_state(self) -> Dict[str, Any]:
+        """
+        Restore session state from memory.
+        
+        Returns:
+            Dictionary of restored state data
+        """
+        # Use metadata-based search for better SQLite compatibility
+        results = self.memory.search_short_term(
+            query=f"type:session_state",
+            limit=10  # Get more results to filter by session_id
+        )
+
+        # Filter results by session_id in metadata
+        for result in results:
+            metadata = result.get("metadata", {})
+            if (metadata.get("type") == "session_state" and 
+                metadata.get("session_id") == self.session_id):
+                # Extract state data from metadata (excluding system fields)
+                state_data = {k: v for k, v in metadata.items() 
+                             if k not in ["type", "session_id", "user_id"]}
+                return state_data
+
+        return {}
+
+    def get_state(self, key: str, default: Any = None) -> Any:
+        """Get a specific state value"""
+        state = self.restore_state()
+        return state.get(key, default)
+
+    def set_state(self, key: str, value: Any) -> None:
+        """Set a specific state value"""
+        current_state = self.restore_state()
+        current_state[key] = value
+        self.save_state(current_state)
+
+    def add_memory(self, text: str, memory_type: str = "long", **metadata) -> None:
+        """
+        Add information to session memory.
+        
+        Args:
+            text: Text to store
+            memory_type: "short" or "long" term memory
+            **metadata: Additional metadata
+        """
+        metadata.update({
+            "session_id": self.session_id,
+            "user_id": self.user_id
+        })
+
+        if memory_type == "short":
+            self.memory.store_short_term(text, metadata=metadata)
+        else:
+            self.memory.store_long_term(text, metadata=metadata)
+
+    def search_memory(self, query: str, memory_type: str = "long", limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Search session memory.
+        
+        Args:
+            query: Search query
+            memory_type: "short" or "long" term memory
+            limit: Maximum results to return
+
+        Returns:
+            List of memory results
+        """
+        if memory_type == "short":
+            return self.memory.search_short_term(query, limit=limit)
+        return self.memory.search_long_term(query, limit=limit)
+
+    def add_knowledge(self, source: str) -> None:
+        """
+        Add knowledge source to session.
+        
+        Args:
+            source: File path, URL, or text content
+        """
+        self.knowledge.add(source, user_id=self.user_id, agent_id=self.session_id)
+
+    def search_knowledge(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Search session knowledge base.
+        
+        Args:
+            query: Search query
+            limit: Maximum results to return
+
+        Returns:
+            List of knowledge results
+        """
+        return self.knowledge.search(query, agent_id=self.session_id, limit=limit)
+
+    def clear_memory(self, memory_type: str = "all") -> None:
+        """
+        Clear session memory.
+        
+        Args:
+            memory_type: "short", "long", or "all"
+        """
+        if memory_type in ["short", "all"]:
+            self.memory.reset_short_term()
+        if memory_type in ["long", "all"]:
+            self.memory.reset_long_term()
+
+    def get_context(self, query: str, max_items: int = 3) -> str:
+        """
+        Build context from session memory and knowledge.
+        
+        Args:
+            query: Query to build context for
+            max_items: Maximum items per section
+
+        Returns:
+            Formatted context string
+        """
+        return self.memory.build_context_for_task(
+            task_descr=query,
+            user_id=self.user_id,
+            max_items=max_items
+        )
+
+    def __str__(self) -> str:
+        return f"Session(id='{self.session_id}', user='{self.user_id}')"
+
+    def __repr__(self) -> str:
+        return self.__str__()

praisonaiagents/task/task.py

@@ -1,6 +1,7 @@
 import logging
 import asyncio
-from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine, Literal
+import inspect
+from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine, Literal, Tuple, get_args, get_origin
 from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
@@ -40,7 +41,10 @@ class Task:
         quality_check=True,
         input_file: Optional[str] = None,
         rerun: bool = False, # Renamed from can_rerun and logic inverted, default True for backward compatibility
-        retain_full_context: bool = False # By default, only use previous task output, not all previous tasks
+        retain_full_context: bool = False, # By default, only use previous task output, not all previous tasks
+        guardrail: Optional[Union[Callable[[TaskOutput], Tuple[bool, Any]], str]] = None,
+        max_retries: int = 3,
+        retry_count: int = 0
     ):
         # Add check if memory config is provided
         if memory is not None or (config and config.get('memory_config')):
@@ -80,6 +84,10 @@ class Task:
         self.quality_check = quality_check
         self.rerun = rerun # Assigning the rerun parameter
         self.retain_full_context = retain_full_context
+        self.guardrail = guardrail
+        self.max_retries = max_retries
+        self.retry_count = retry_count
+        self._guardrail_fn = None
 
         # Set logger level based on config verbose level
         verbose = self.config.get("verbose", 0)
@@ -141,6 +149,55 @@ class Task:
 
             self.output_pydantic = LoopModel
 
+        # Initialize guardrail
+        self._setup_guardrail()
+
+    def _setup_guardrail(self):
+        """Setup the guardrail function based on the provided guardrail parameter."""
+        if self.guardrail is None:
+            self._guardrail_fn = None
+            return
+            
+        if callable(self.guardrail):
+            # Validate function signature
+            sig = inspect.signature(self.guardrail)
+            positional_args = [
+                param for param in sig.parameters.values()
+                if param.default is inspect.Parameter.empty
+            ]
+            if len(positional_args) != 1:
+                raise ValueError("Guardrail function must accept exactly one parameter (TaskOutput)")
+            
+            # Check return annotation if present
+            return_annotation = sig.return_annotation
+            if return_annotation != inspect.Signature.empty:
+                return_annotation_args = get_args(return_annotation)
+                if not (
+                    get_origin(return_annotation) is tuple
+                    and len(return_annotation_args) == 2
+                    and return_annotation_args[0] is bool
+                    and (
+                        return_annotation_args[1] is Any
+                        or return_annotation_args[1] is str
+                        or return_annotation_args[1] is TaskOutput
+                        or return_annotation_args[1] == Union[str, TaskOutput]
+                    )
+                ):
+                    raise ValueError(
+                        "If return type is annotated, it must be Tuple[bool, Any]"
+                    )
+            
+            self._guardrail_fn = self.guardrail
+        elif isinstance(self.guardrail, str):
+            # Create LLM-based guardrail
+            from ..guardrails import LLMGuardrail
+            if not self.agent:
+                raise ValueError("Agent is required for string-based guardrails")
+            llm = getattr(self.agent, 'llm', None) or getattr(self.agent, 'llm_instance', None)
+            self._guardrail_fn = LLMGuardrail(description=self.guardrail, llm=llm)
+        else:
+            raise ValueError("Guardrail must be either a callable or a string description")
+
     def __str__(self):
         return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
 
@@ -187,6 +244,37 @@ class Task:
         logger.info(f"Task {self.id}: execute_callback called")
         logger.info(f"Quality check enabled: {self.quality_check}")
 
+        # Process guardrail if configured
+        if self._guardrail_fn:
+            try:
+                guardrail_result = self._process_guardrail(task_output)
+                if not guardrail_result.success:
+                    if self.retry_count >= self.max_retries:
+                        raise Exception(
+                            f"Task failed guardrail validation after {self.max_retries} retries. "
+                            f"Last error: {guardrail_result.error}"
+                        )
+                    
+                    self.retry_count += 1
+                    logger.warning(f"Task {self.id}: Guardrail validation failed (retry {self.retry_count}/{self.max_retries}): {guardrail_result.error}")
+                    # Note: In a real execution, this would trigger a retry, but since this is a callback
+                    # the retry logic would need to be handled at the agent/execution level
+                    return
+                
+                # If guardrail passed and returned a modified result
+                if guardrail_result.result is not None:
+                    if isinstance(guardrail_result.result, str):
+                        # Update the task output with the modified result
+                        task_output.raw = guardrail_result.result
+                    elif isinstance(guardrail_result.result, TaskOutput):
+                        # Replace with the new task output
+                        task_output = guardrail_result.result
+                
+                logger.info(f"Task {self.id}: Guardrail validation passed")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Error in guardrail processing: {e}")
+                # Continue execution even if guardrail fails to avoid breaking the task
+
         # Initialize memory if not already initialized
         if not self.memory:
             self.memory = self.initialize_memory()
@@ -334,4 +422,34 @@ Context:
                 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))
+            asyncio.run(self.execute_callback(task_output))
+
+    def _process_guardrail(self, task_output: TaskOutput):
+        """Process the guardrail validation for a task output.
+        
+        Args:
+            task_output: The task output to validate
+            
+        Returns:
+            GuardrailResult: The result of the guardrail validation
+        """
+        from ..guardrails import GuardrailResult
+        
+        if not self._guardrail_fn:
+            return GuardrailResult(success=True, result=task_output)
+        
+        try:
+            # Call the guardrail function
+            result = self._guardrail_fn(task_output)
+            
+            # Convert the result to a GuardrailResult
+            return GuardrailResult.from_tuple(result)
+            
+        except Exception as e:
+            logger.error(f"Task {self.id}: Error in guardrail validation: {e}")
+            # On error, return failure
+            return GuardrailResult(
+                success=False,
+                result=None,
+                error=f"Guardrail validation error: {str(e)}"
+            )

praisonaiagents/tools/file_tools.py

@@ -16,6 +16,7 @@ from typing import List, Dict, Union, Optional
 from pathlib import Path
 import shutil
 import logging
+from ..approval import require_approval
 
 class FileTools:
     """Tools for file operations including read, write, list, and information."""
@@ -41,6 +42,7 @@ class FileTools:
             return error_msg
 
     @staticmethod
+    @require_approval(risk_level="high")
     def write_file(filepath: str, content: str, encoding: str = 'utf-8') -> bool:
         """
         Write content to a file.
@@ -134,6 +136,7 @@ class FileTools:
             return {'error': error_msg}
 
     @staticmethod
+    @require_approval(risk_level="high")
     def copy_file(src: str, dst: str) -> bool:
         """
         Copy a file from source to destination.
@@ -156,6 +159,7 @@ class FileTools:
             return False
 
     @staticmethod
+    @require_approval(risk_level="high")
     def move_file(src: str, dst: str) -> bool:
         """
         Move a file from source to destination.
@@ -178,6 +182,7 @@ class FileTools:
             return False
 
     @staticmethod
+    @require_approval(risk_level="high")
     def delete_file(filepath: str) -> bool:
         """
         Delete a file.

praisonaiagents/tools/python_tools.py

@@ -15,6 +15,7 @@ from importlib import util
 import io
 from contextlib import redirect_stdout, redirect_stderr
 import traceback
+from ..approval import require_approval
 
 class PythonTools:
     """Tools for Python code execution and analysis."""
@@ -36,6 +37,7 @@ class PythonTools:
                 f"Run: pip install {' '.join(missing)}"
             )
 
+    @require_approval(risk_level="critical")
     def execute_code(
         self,
         code: str,

praisonaiagents/tools/shell_tools.py

@@ -13,6 +13,7 @@ import logging
 import os
 import time
 from typing import Dict, List, Optional, Union
+from ..approval import require_approval
 
 class ShellTools:
     """Tools for executing shell commands safely."""
@@ -31,6 +32,7 @@ class ShellTools:
                 "Run: pip install psutil"
             )
     
+    @require_approval(risk_level="critical")
     def execute_command(
         self,
         command: str,
@@ -146,6 +148,7 @@ class ShellTools:
             logging.error(error_msg)
             return []
     
+    @require_approval(risk_level="critical")
     def kill_process(
         self,
         pid: int,

{praisonaiagents-0.0.96.dist-info → praisonaiagents-0.0.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.96
+Version: 0.0.98
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
@@ -19,6 +19,9 @@ Requires-Dist: mem0ai>=0.1.0; extra == "knowledge"
 Requires-Dist: chromadb>=1.0.0; extra == "knowledge"
 Requires-Dist: markitdown[all]>=0.1.0; extra == "knowledge"
 Requires-Dist: chonkie>=1.0.2; extra == "knowledge"
+Provides-Extra: graph
+Requires-Dist: mem0ai[graph]>=0.1.0; extra == "graph"
+Requires-Dist: chromadb>=1.0.0; extra == "graph"
 Provides-Extra: llm
 Requires-Dist: litellm>=1.50.0; extra == "llm"
 Requires-Dist: pydantic>=2.4.2; extra == "llm"
@@ -28,6 +31,7 @@ Requires-Dist: uvicorn>=0.34.0; extra == "api"
 Provides-Extra: all
 Requires-Dist: praisonaiagents[memory]; extra == "all"
 Requires-Dist: praisonaiagents[knowledge]; extra == "all"
+Requires-Dist: praisonaiagents[graph]; extra == "all"
 Requires-Dist: praisonaiagents[llm]; extra == "all"
 Requires-Dist: praisonaiagents[mcp]; extra == "all"
 Requires-Dist: praisonaiagents[api]; extra == "all"

{praisonaiagents-0.0.96.dist-info → praisonaiagents-0.0.98.dist-info}/RECORD

@@ -1,24 +1,26 @@
-praisonaiagents/__init__.py,sha256=Z2_rSA6mYozz0r3ioUgKzl3QV8uWRDS_QaqPg2oGjqg,1324
-praisonaiagents/main.py,sha256=D6XzpqdfglCQiWaH5LjRSv-bB3QkJso-i0h1uTFkPQI,15844
+praisonaiagents/__init__.py,sha256=GmTiMNta4iwmfarh_6cTUpry50hpqFE8YqolrYfZ_7U,1465
+praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9813
+praisonaiagents/main.py,sha256=_-XE7_Y7ChvtLQMivfNFrrnAhv4wSSDhH9WJMWlkS0w,16315
+praisonaiagents/session.py,sha256=CI-ffCiOfmgB-1zFFik9daKCB5Sm41Q9ZOaq1-oSLW8,9250
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
-praisonaiagents/agent/agent.py,sha256=DPpTgobDVZw2qlPzvNS-Xi-OF3RlM2cil6y15cbXIy8,86553
+praisonaiagents/agent/agent.py,sha256=be5E_uEXxZo4xmRRoRQoCpZ964pzlakC_QCOOsG4rCA,88440
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=-cWRgok0X_4Mk-L7dW6bFdX7JVpxfe7R6aLmukktwKc,59381
+praisonaiagents/agents/agents.py,sha256=C_yDdJB4XUuwKA9DrysAtAj3zSYT0IKtfCT4Pxo0oyI,63309
 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=7Qk6qvUanapzdM1B_bik645PcorErKlAvADf5iKXrTE,14289
+praisonaiagents/knowledge/knowledge.py,sha256=OKPar-XGyAp1ndmbOOdCgqFnTCqpOThYVSIZRxZyP58,15683
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=9wHmf0aGKf4a7YZ4JONmD7Ela8JBYVrkMFF2ei8Ivpk,93400
+praisonaiagents/llm/llm.py,sha256=SzD_qoUqQnC9FpY-d1HHqKQGkIGPR5wEmE1OcqVEPFY,93577
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=_gfp8hrSVT9aPqEDDfU8MiCdg0-3dVQpEQUE6AbrJlo,17243
 praisonaiagents/mcp/mcp_sse.py,sha256=DLh3F_aoVRM1X-7hgIOWOw4FQ1nGmn9YNbQTesykzn4,6792
-praisonaiagents/memory/memory.py,sha256=XvX2fohxyyP8RihbbtOZYt0g-bIDEyLwzfNCWV2Ayok,36175
+praisonaiagents/memory/memory.py,sha256=6tvsLWkpvyNU-t-8d6XpW7vOFUm1pNReW5B7rA8c04M,38612
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=gxhMXG3s4CzaREyuwE5zxCMx2Wp_b_Wd53tDfkj8Qk8,66567
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=03Vcz3TaKIYnryFnKAuuQ7Ly5nTaxysFpem6sgn4gJA,15112
+praisonaiagents/task/task.py,sha256=60JE07JPpRowbEO420f4Ol49e_1AK856wSJDi_ricbg,20531
 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
@@ -26,12 +28,12 @@ praisonaiagents/tools/csv_tools.py,sha256=4Yr0QYwBXt-1BDXGLalB2eSsFR2mB5rH3KdHmR
 praisonaiagents/tools/duckdb_tools.py,sha256=KB3b-1HcX7ocoxskDpk_7RRpTGHnH8hizIY0ZdLRbIE,8816
 praisonaiagents/tools/duckduckgo_tools.py,sha256=ynlB5ZyWfHYjUq0JZXH12TganqTihgD-2IyRgs32y84,1657
 praisonaiagents/tools/excel_tools.py,sha256=e2HqcwnyBueOyss0xEKxff3zB4w4sNWCOMXvZfbDYlE,11309
-praisonaiagents/tools/file_tools.py,sha256=KRskI9q8up3sHaLQSaIGtvpl1brq419Up6YvB9QzSoI,8807
+praisonaiagents/tools/file_tools.py,sha256=-RE1LfJA3vr7JYoHQaElGTLMAEvc0NvN8pCsO8YGOHg,9011
 praisonaiagents/tools/json_tools.py,sha256=ApUYNuQ1qnbmYNCxSlx6Tth_H1yo8mhWtZ7Rr2WS6C4,16507
 praisonaiagents/tools/newspaper_tools.py,sha256=NyhojNPeyULBGcAWGOT1X70qVkh3FgZrpH-S7PEmrwI,12667
 praisonaiagents/tools/pandas_tools.py,sha256=yzCeY4jetKrFIRA15Tr5OQ5d94T8DaSpzglx2UiWfPs,11092
-praisonaiagents/tools/python_tools.py,sha256=ByBpESi5Vk2ivpihav9AQeqf95K_D4qqINYN1q-q0bA,13428
-praisonaiagents/tools/shell_tools.py,sha256=P3fSrfOw71CGcrPwdPOA9Fr6Bgt_CAC71bUjCyvZCN8,9301
+praisonaiagents/tools/python_tools.py,sha256=puqLANl5YaG1YG8ixkl_MgWayF7uj5iXUEE15UYwIZE,13513
+praisonaiagents/tools/shell_tools.py,sha256=6IlnFkNg04tVxQVM_fYgscIWLtcgIikpEi3olB1THuA,9431
 praisonaiagents/tools/spider_tools.py,sha256=lrZnT1V1BC46We-AzBrDB1Ryifr3KKGmYNntMsScU7w,15094
 praisonaiagents/tools/test.py,sha256=UHOTNrnMo0_H6I2g48re1WNZkrR7f6z25UnlWxiOSbM,1600
 praisonaiagents/tools/tools.py,sha256=TK5njOmDSpMlyBnbeBzNSlnzXWlnNaTpVqkFPhkMArg,265
@@ -40,7 +42,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.96.dist-info/METADATA,sha256=QxdS4_rx41RYGsDT5GO5G3g-D-l1HGzTPIxSZxaK_aQ,1273
-praisonaiagents-0.0.96.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.96.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.96.dist-info/RECORD,,
+praisonaiagents-0.0.98.dist-info/METADATA,sha256=CGUF2azfrJRTc_js-tPZRX4-U2MIGe8v9wcCWa0pL6w,1452
+praisonaiagents-0.0.98.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.98.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.98.dist-info/RECORD,,