Merge pull request #582 from MervinPraison/develop

Develop

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.2.24" \
+    "praisonai>=2.2.25" \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.24" \
+    "praisonai>=2.2.25" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.24" \
+    "praisonai>=2.2.25" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.24" \
+    "praisonai>=2.2.25" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docker/README.md

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions
 
 All Docker images use consistent, up-to-date versions:
-- PraisonAI: `>=2.2.24`
+- PraisonAI: `>=2.2.25`
 - PraisonAI Agents: `>=0.0.92`
 - Python: `3.11-slim`
 
@@ -218,7 +218,7 @@ docker-compose up -d
 ### Version Pinning
 To use specific versions, update the Dockerfile:
 ```dockerfile
-RUN pip install "praisonai==2.2.24" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.25" "praisonaiagents==0.0.92"
 ```
 
 ## 🌐 Production Deployment

docs/api/praisonai/deploy.html

@@ -110,7 +110,7 @@ Loads environment variables from .env file or system and sets them.</p>
             file.write(&#34;FROM python:3.11-slim\n&#34;)
             file.write(&#34;WORKDIR /app\n&#34;)
             file.write(&#34;COPY . .\n&#34;)
-            file.write(&#34;RUN pip install flask praisonai==2.2.24 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.2.25 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/developers/local-development.mdx

@@ -27,7 +27,7 @@ WORKDIR /app
 
 COPY . .
 
-RUN pip install flask praisonai==2.2.24 watchdog
+RUN pip install flask praisonai==2.2.25 watchdog
 
 EXPOSE 5555
 

docs/ui/chat.mdx

@@ -155,7 +155,7 @@ To facilitate local development with live reload, you can use Docker. Follow the
 
     COPY . .
 
-    RUN pip install flask praisonai==2.2.24 watchdog
+    RUN pip install flask praisonai==2.2.25 watchdog
 
     EXPOSE 5555
 

docs/ui/code.mdx

@@ -208,7 +208,7 @@ To facilitate local development with live reload, you can use Docker. Follow the
 
     COPY . .
 
-    RUN pip install flask praisonai==2.2.24 watchdog
+    RUN pip install flask praisonai==2.2.25 watchdog
 
     EXPOSE 5555
 

examples/python/general/human_approval_example.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Human Approval Example for PraisonAI Agents
+
+This example demonstrates the human-in-the-loop approval system for dangerous operations.
+When agents attempt to execute high-risk tools (like shell commands or file operations),
+the system will prompt the user for approval before proceeding.
+
+Usage:
+    python human_approval_example.py
+
+Features:
+- Automatic approval prompts for dangerous tools
+- Risk level classification (critical, high, medium, low)  
+- User can approve, deny, or modify tool arguments
+- Console-based approval interface with rich formatting
+"""
+
+import asyncio
+import logging
+import os
+import sys
+
+# Add the local development path to use the current implementation
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..', 'src', 'praisonai-agents'))
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import python_tools, file_tools, shell_tools
+from praisonaiagents.main import register_approval_callback
+from praisonaiagents.approval import (
+    console_approval_callback, 
+    ApprovalDecision,
+    add_approval_requirement,
+    remove_approval_requirement
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+def custom_approval_callback(function_name: str, arguments: dict, risk_level: str) -> ApprovalDecision:
+    """
+    Custom approval callback that demonstrates how to implement
+    custom approval logic beyond the default console prompts.
+    """
+    print(f"\n🔒 CUSTOM APPROVAL REQUIRED")
+    print(f"Function: {function_name}")
+    print(f"Risk Level: {risk_level}")
+    print(f"Arguments: {arguments}")
+    
+    # Example: Auto-approve low-risk operations
+    if risk_level == "low":
+        print("✅ Auto-approving low-risk operation")
+        return ApprovalDecision(approved=True, reason="Auto-approved low risk")
+    
+    # Example: Always deny certain dangerous commands
+    if function_name == "execute_command" and any(
+        dangerous in str(arguments.get("command", "")) 
+        for dangerous in ["rm -rf", "del /f", "format", "shutdown"]
+    ):
+        print("❌ Automatically denying dangerous command")
+        return ApprovalDecision(approved=False, reason="Dangerous command blocked")
+    
+    # For other cases, use the default console approval
+    return console_approval_callback(function_name, arguments, risk_level)
+
+def main():
+    """Demonstrate human approval system with various dangerous operations."""
+    
+    print("🤖 PraisonAI Human Approval System Demo")
+    print("=" * 50)
+    print("This demo will show approval prompts for dangerous operations.")
+    print("You can approve or deny each operation as it's requested.")
+    print()
+    
+    # Option 1: Use default console approval callback (automatic)
+    # Option 2: Use custom approval callback
+    # Uncomment the line below to use custom approval logic:
+    # register_approval_callback(custom_approval_callback)
+    
+    # Create agent with dangerous tools
+    agent = Agent(
+        name="Security Demo Agent",
+        role="System Administrator",
+        goal="Demonstrate human approval for dangerous operations",
+        tools=[python_tools, file_tools, shell_tools],
+        verbose=True
+    )
+    
+    # Define tasks that will trigger approval prompts
+    tasks = [
+        Task(
+            description="Execute a simple Python print statement",
+            agent=agent,
+            expected_output="Python code execution result"
+        ),
+        Task(
+            description="Create a test file with some content",
+            agent=agent,
+            expected_output="File creation confirmation"
+        ),
+        Task(
+            description="List the current directory contents using shell command",
+            agent=agent,
+            expected_output="Directory listing"
+        ),
+        Task(
+            description="Delete the test file that was created",
+            agent=agent,
+            expected_output="File deletion confirmation"
+        )
+    ]
+    
+    # Create and run process
+    process = PraisonAIAgents(
+        agents=[agent],
+        tasks=tasks,
+        verbose=True
+    )
+    
+    print("\n🚀 Starting process with approval-required operations...")
+    print("You will be prompted to approve each dangerous operation.")
+    print()
+    
+    try:
+        result = process.start()
+        print(f"\n✅ Process completed successfully!")
+        print(f"Final result: {result}")
+    except KeyboardInterrupt:
+        print("\n❌ Process cancelled by user")
+    except Exception as e:
+        print(f"\n❌ Process failed: {e}")
+
+def demo_manual_approval_configuration():
+    """Demonstrate how to manually configure approval requirements."""
+    
+    print("\n📋 Manual Approval Configuration Demo")
+    print("=" * 40)
+    
+    # Add approval requirement for a normally safe operation
+    add_approval_requirement("list_files", "medium")
+    print("✅ Added approval requirement for 'list_files' (medium risk)")
+    
+    # Remove approval requirement for a normally dangerous operation
+    remove_approval_requirement("write_file")
+    print("✅ Removed approval requirement for 'write_file'")
+    
+    # Show current approval requirements
+    from praisonaiagents.approval import APPROVAL_REQUIRED_TOOLS, TOOL_RISK_LEVELS
+    print(f"\nCurrent approval-required tools: {list(APPROVAL_REQUIRED_TOOLS)}")
+    print(f"Tool risk levels: {TOOL_RISK_LEVELS}")
+
+async def async_demo():
+    """Demonstrate approval system with async operations."""
+    
+    print("\n🔄 Async Approval Demo")
+    print("=" * 25)
+    
+    # Create async agent
+    agent = Agent(
+        name="Async Demo Agent",
+        role="Async Operations Specialist", 
+        goal="Demonstrate async approval workflow",
+        tools=[python_tools],
+        verbose=True
+    )
+    
+    # This would trigger approval in async context
+    task = Task(
+        description="Execute async Python code that prints 'Hello from async!'",
+        agent=agent,
+        expected_output="Async execution result"
+    )
+    
+    process = PraisonAIAgents(
+        agents=[agent],
+        tasks=[task],
+        verbose=True
+    )
+    
+    try:
+        result = await process.astart()
+        print(f"✅ Async process completed: {result}")
+    except Exception as e:
+        print(f"❌ Async process failed: {e}")
+
+if __name__ == "__main__":
+    print(__doc__)
+    
+    # Run the main demo
+    main()
+    
+    # Show manual configuration options
+    demo_manual_approval_configuration()
+    
+    # Demonstrate async approval (optional)
+    print("\n" + "=" * 50)
+    print("Would you like to run the async demo as well? (y/n): ", end="")
+    try:
+        if input().lower().startswith('y'):
+            asyncio.run(async_demo())
+    except KeyboardInterrupt:
+        print("\nDemo cancelled.")
+    
+    print("\n🎉 Human approval demo completed!")
+    print("\nKey takeaways:")
+    print("- Dangerous operations automatically prompt for approval")
+    print("- Risk levels help prioritize approval decisions")
+    print("- Custom approval callbacks allow for automated policies")
+    print("- Both sync and async operations are supported")
+    print("- Approval requirements can be configured at runtime")

examples/python/memory/graph-knowledge-example.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+Graph Knowledge Example
+
+This example shows how to use graph memory with the Knowledge class
+for enhanced document processing and relationship extraction.
+
+Requirements:
+    pip install "praisonaiagents[graph]"
+"""
+
+import os
+from praisonaiagents.knowledge import Knowledge
+
+def main():
+    print("📚 Graph Knowledge Example")
+    print("=" * 40)
+    
+    # Configuration with graph memory support
+    config_with_graph = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "graph_knowledge_test",
+                "path": ".praison/graph_knowledge"
+            }
+        },
+        "graph_store": {
+            "provider": "memgraph",  # or "neo4j"
+            "config": {
+                "url": "bolt://localhost:7687",
+                "username": "memgraph",
+                "password": ""
+            }
+        },
+        "llm": {
+            "provider": "openai",
+            "config": {
+                "model": "gpt-4o-mini"
+            }
+        },
+        "embedder": {
+            "provider": "openai",
+            "config": {
+                "model": "text-embedding-3-small"
+            }
+        },
+        "reranker": {
+            "enabled": True,
+            "default_rerank": True
+        }
+    }
+    
+    # Fallback configuration (without graph store)
+    config_basic = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "basic_knowledge_test",
+                "path": ".praison/basic_knowledge"
+            }
+        },
+        "reranker": {
+            "enabled": True,
+            "default_rerank": True
+        }
+    }
+    
+    try:
+        # Try graph-enabled knowledge first
+        knowledge = Knowledge(config=config_with_graph, verbose=1)
+        print("✅ Graph memory enabled!")
+        graph_mode = True
+    except Exception as e:
+        print(f"⚠️  Graph memory not available: {e}")
+        print("📦 Falling back to vector-only memory...")
+        knowledge = Knowledge(config=config_basic, verbose=1)
+        graph_mode = False
+    
+    # Sample documents with rich relationship information
+    documents = [
+        """
+        OpenAI is an artificial intelligence research company founded in 2015. 
+        The company was co-founded by Sam Altman, Greg Brockman, and Elon Musk, 
+        among others. Sam Altman serves as the CEO, while Greg Brockman is the 
+        President and Chairman. Elon Musk was initially involved but left the 
+        board in 2018.
+        """,
+        """
+        GPT-4 is OpenAI's most advanced language model, released in March 2023. 
+        It powers ChatGPT Plus and is available through OpenAI's API. GPT-4 
+        demonstrates improved reasoning and reduced hallucinations compared to 
+        its predecessor GPT-3.5. The model uses transformer architecture and 
+        was trained using reinforcement learning from human feedback (RLHF).
+        """,
+        """
+        Microsoft has a significant partnership with OpenAI, having invested 
+        billions of dollars in the company. This partnership allows Microsoft 
+        to integrate OpenAI's models into products like Microsoft Copilot, 
+        which is built into Office 365 and Windows. The collaboration gives 
+        Microsoft exclusive access to GPT models for certain use cases.
+        """,
+        """
+        Anthropic is a major competitor to OpenAI, founded by former OpenAI 
+        researchers including Dario Amodei and Daniela Amodei. Anthropic 
+        created Claude, an AI assistant that competes with ChatGPT. The company 
+        focuses on AI safety research and constitutional AI training methods.
+        """
+    ]
+    
+    print(f"\n📥 Adding {len(documents)} documents to knowledge base...")
+    
+    # Add documents to knowledge base
+    for i, doc in enumerate(documents, 1):
+        try:
+            result = knowledge.add(doc, user_id="demo_user")
+            print(f"✓ Document {i} added successfully")
+            if graph_mode:
+                print(f"  Graph relationships extracted and stored")
+        except Exception as e:
+            print(f"❌ Error adding document {i}: {e}")
+    
+    print("\n🔍 Testing relationship-aware queries...")
+    
+    # Test queries that benefit from graph relationships
+    queries = [
+        "Who founded OpenAI?",
+        "What is the relationship between OpenAI and Microsoft?",
+        "How does GPT-4 compare to other models?",
+        "Who are OpenAI's competitors?",
+        "What role does Sam Altman play at OpenAI?",
+        "How is Anthropic related to OpenAI?"
+    ]
+    
+    for query in queries:
+        print(f"\n❓ Query: {query}")
+        try:
+            results = knowledge.search(query, user_id="demo_user", limit=2)
+            
+            if results and hasattr(results, '__iter__'):
+                for i, result in enumerate(results, 1):
+                    if hasattr(result, 'get'):
+                        content = result.get('memory', result.get('text', str(result)))
+                    else:
+                        content = str(result)
+                    
+                    # Truncate long responses
+                    if len(content) > 200:
+                        content = content[:197] + "..."
+                    
+                    print(f"  {i}. {content}")
+            else:
+                print("  No results found")
+                
+        except Exception as e:
+            print(f"  ❌ Search error: {e}")
+    
+    print(f"\n{'✅ Graph Knowledge Example Complete!' if graph_mode else '✅ Basic Knowledge Example Complete!'}")
+    print("=" * 40)
+    
+    if graph_mode:
+        print("🧠 Graph memory successfully captured entity relationships!")
+        print("   Queries benefit from understanding connections between entities.")
+    else:
+        print("📦 Vector memory provided semantic search capabilities.")
+        print("💡 To enable graph memory, set up Neo4j or Memgraph and install:")
+        print("   pip install \"mem0ai[graph]\"")
+
+if __name__ == "__main__":
+    if not os.getenv("OPENAI_API_KEY"):
+        print("⚠️  Warning: OPENAI_API_KEY not set.")
+        print("   Export your key: export OPENAI_API_KEY='your-key-here'")
+        print("   Some features may not work without it.\n")
+    
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n👋 Example interrupted by user")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        print("💡 Make sure you have the required dependencies installed:")
+        print("   pip install \"praisonaiagents[graph]\"")

examples/python/memory/graph-memory-agent.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+Graph Memory Agent Example
+
+This example demonstrates how to use Mem0's graph memory capabilities 
+with PraisonAI agents to create and utilize complex relationships 
+between pieces of information.
+
+Requirements:
+    pip install "praisonaiagents[graph]"
+
+Setup:
+    - For Neo4j: Set up a Neo4j instance (local or AuraDB)
+    - For Memgraph: Run with Docker: 
+      docker run -p 7687:7687 memgraph/memgraph-mage:latest --schema-info-enabled=True
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+def main():
+    # Example with Neo4j (uncomment and configure as needed)
+    neo4j_config = {
+        "provider": "mem0",
+        "config": {
+            "graph_store": {
+                "provider": "neo4j",
+                "config": {
+                    "url": "neo4j+s://your-instance.databases.neo4j.io",
+                    "username": "neo4j",
+                    "password": "your-password"
+                }
+            },
+            "vector_store": {
+                "provider": "qdrant",
+                "config": {
+                    "host": "localhost",
+                    "port": 6333
+                }
+            },
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4o-mini"
+                }
+            }
+        }
+    }
+    
+    # Example with Memgraph (local setup)
+    memgraph_config = {
+        "provider": "mem0",
+        "config": {
+            "graph_store": {
+                "provider": "memgraph",
+                "config": {
+                    "url": "bolt://localhost:7687",
+                    "username": "memgraph",
+                    "password": ""
+                }
+            },
+            "vector_store": {
+                "provider": "qdrant",
+                "config": {
+                    "host": "localhost", 
+                    "port": 6333
+                }
+            },
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4o-mini"
+                }
+            }
+        }
+    }
+    
+    # Simple local configuration (fallback to vector-only memory)
+    local_config = {
+        "provider": "mem0",
+        "config": {
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "path": ".praison/graph_memory"
+                }
+            }
+        }
+    }
+    
+    # Use local config by default (can be switched to neo4j_config or memgraph_config)
+    memory_config = local_config
+    
+    print("🧠 Graph Memory Agent Example")
+    print("=" * 50)
+    
+    # Define research agent
+    researcher = Agent(
+        name="Knowledge Researcher", 
+        role="AI Research Specialist",
+        goal="Research and build knowledge graphs about AI and technology relationships",
+        backstory="""You are an expert at identifying relationships between concepts, 
+        people, technologies, and ideas. You excel at creating structured knowledge 
+        that captures complex interconnections.""",
+        verbose=True,
+        memory=True
+    )
+    
+    # Task 1: Build initial knowledge graph
+    build_knowledge_task = Task(
+        description="""Research and store information about the relationships between:
+        1. OpenAI and its key products (GPT-4, ChatGPT, DALL-E)
+        2. Key people: Sam Altman (CEO), Greg Brockman (Co-founder)
+        3. Partnerships: Microsoft partnership and investment
+        4. Competitors: Anthropic, Google, Meta
+        5. Technologies: Transformer architecture, reinforcement learning
+        
+        Focus on capturing the relationships and connections between these entities.
+        Store comprehensive information about how these elements relate to each other.""",
+        expected_output="Detailed knowledge graph with entities and relationships about OpenAI ecosystem",
+        agent=researcher
+    )
+    
+    # Task 2: Query and expand knowledge
+    query_knowledge_task = Task(
+        description="""Based on the previously stored knowledge, answer these questions:
+        1. Who are the key leaders at OpenAI and what are their roles?
+        2. What are the main products and how do they relate to each other?
+        3. Who are OpenAI's main competitors and how do they compare?
+        4. What is the relationship between OpenAI and Microsoft?
+        
+        Use the stored memory to provide comprehensive answers that leverage 
+        the relationship information.""",
+        expected_output="Comprehensive answers utilizing relationship-aware memory retrieval",
+        agent=researcher
+    )
+    
+    # Task 3: Add new connections
+    expand_knowledge_task = Task(
+        description="""Add new information to the knowledge graph:
+        1. Elon Musk was a co-founder of OpenAI but left the board
+        2. OpenAI started as a non-profit but created a capped-profit subsidiary
+        3. GPT-4 powers ChatGPT and is also available via API
+        4. DALL-E uses diffusion models for image generation
+        5. OpenAI's research influences the broader AI field
+        
+        Ensure these new facts are connected to the existing knowledge graph.""",
+        expected_output="Updated knowledge graph with new relationships and connections",
+        agent=researcher
+    )
+    
+    # Run the multi-agent system with graph memory
+    agents_system = PraisonAIAgents(
+        agents=[researcher],
+        tasks=[build_knowledge_task, query_knowledge_task, expand_knowledge_task],
+        verbose=1,
+        memory=True,
+        memory_config=memory_config
+    )
+    
+    print("\n🚀 Starting graph memory demonstration...")
+    result = agents_system.start()
+    
+    print("\n✅ Graph Memory Example Complete!")
+    print("=" * 50)
+    print("The agent has built and queried a knowledge graph that captures")
+    print("complex relationships between entities, demonstrating how graph memory")
+    print("enhances traditional vector-based memory with relationship awareness.")
+    
+    return result
+
+def test_direct_memory_api():
+    """
+    Direct example using the Memory class with graph support
+    """
+    print("\n🔬 Direct Memory API Test")
+    print("=" * 30)
+    
+    from praisonaiagents.memory import Memory
+    
+    # Configure memory with graph support (using local fallback)
+    memory_config = {
+        "provider": "mem0",
+        "config": {
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "path": ".praison/test_graph_memory"
+                }
+            }
+        }
+    }
+    
+    memory = Memory(config=memory_config, verbose=5)
+    
+    # Test storing user memories with relationships
+    user_id = "alice"
+    
+    memories = [
+        "I love hiking in the mountains",
+        "My friend John also loves hiking", 
+        "John has a dog named Max",
+        "Max loves to go on hikes with us",
+        "We often hike in Yosemite National Park",
+        "Yosemite has beautiful waterfalls"
+    ]
+    
+    print("Storing memories with potential relationships...")
+    for memory_text in memories:
+        memory.store_user_memory(user_id, memory_text)
+        print(f"✓ Stored: {memory_text}")
+    
+    print("\nSearching for relationship-aware memories...")
+    
+    # Test relationship-aware searches
+    queries = [
+        "Who likes hiking?",
+        "Tell me about John",
+        "What do we know about dogs?",
+        "Where do they go hiking?"
+    ]
+    
+    for query in queries:
+        print(f"\n🔍 Query: {query}")
+        results = memory.search_user_memory(user_id, query, limit=3, rerank=True)
+        for i, result in enumerate(results, 1):
+            if isinstance(result, dict):
+                print(f"  {i}. {result.get('memory', result.get('text', str(result)))}")
+            else:
+                print(f"  {i}. {result}")
+
+if __name__ == "__main__":
+    # Check if required environment variables are set
+    if not os.getenv("OPENAI_API_KEY"):
+        print("⚠️  Warning: OPENAI_API_KEY not set. Some features may not work.")
+        print("   Set your API key: export OPENAI_API_KEY='your-key-here'")
+    
+    try:
+        # Run the main agent example
+        main()
+        
+        # Run direct API test
+        test_direct_memory_api()
+        
+    except ImportError as e:
+        print(f"❌ Import Error: {e}")
+        print("💡 Try installing graph memory support:")
+        print("   pip install \"praisonaiagents[graph]\"")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        print("💡 Make sure you have the required dependencies and configuration.")

examples/python/usecases/README-domain-context.md

@@ -0,0 +1,81 @@
+# Domain Context Solution
+
+This example demonstrates how to solve domain context issues in multi-agent systems using existing PraisonAI features.
+
+## Problem
+
+In hierarchical multi-agent workflows, tools often default to generic values like "example.com" instead of using user-specified domains. This happens because domain context doesn't automatically reach the tool execution level.
+
+## Solution: 4-Layer Context Approach
+
+This solution uses four existing PraisonAI features to ensure domain context is properly maintained:
+
+### 1. **Custom Tool Wrappers**
+```python
+def create_domain_aware_tools(target_domain: str):
+    def query_fofa(query: str = None) -> dict:
+        if query is None or query == "example.com":
+            query = target_domain
+        # Tool implementation with domain injection
+```
+
+### 2. **Agent Instructions**
+```python
+agent = Agent(
+    instructions=f"""
+    CRITICAL DOMAIN CONTEXT: You are working exclusively with the domain '{domain}'. 
+    All operations, tool calls, and analysis must focus on this specific domain.
+    Never use example.com or generic examples - always use {domain}.
+    """,
+    tools=domain_tools
+)
+```
+
+### 3. **Task Context Parameter**
+```python
+task = Task(
+    description=f"Analyze domain {domain}",
+    context=[domain_context.get_context()],  # Pass domain context
+    agent=agent
+)
+```
+
+### 4. **Shared Memory**
+```python
+agents = PraisonAIAgents(
+    agents=[agent1, agent2],
+    tasks=[task1, task2],
+    memory=True,  # Enable shared memory for context
+    memory_config={
+        "provider": "rag",
+        "config": {"collection_name": f"{domain}_analysis"}
+    }
+)
+```
+
+## Usage
+
+```python
+from domain_context_solution import main
+
+# Set your target domain
+domain = "your-domain.com"
+
+# Run the hierarchical workflow
+main()
+```
+
+## Key Benefits
+
+- ✅ **No Core SDK Changes** - Uses only existing framework features
+- ✅ **Multi-Layer Reliability** - Context maintained through multiple mechanisms
+- ✅ **Domain-Specific Results** - Tools focus on specified domain
+- ✅ **Backward Compatible** - Doesn't break existing functionality
+- ✅ **Scalable Pattern** - Works for any domain or context type
+
+## Files
+
+- `domain-context-solution.py` - Complete working solution
+- `README-domain-context.md` - This documentation
+
+This pattern can be adapted for any context passing scenario in PraisonAI multi-agent systems.

examples/python/usecases/domain-context-solution.py

@@ -0,0 +1,321 @@
+"""
+SOLUTION: Domain Context Issue Fix using Existing PraisonAI Features
+
+This solution fixes the issue where agents default to "example.com" instead of using 
+the specified domain "eenadu.net" by leveraging existing PraisonAI context features.
+
+Key improvements:
+1. Domain context passed through task context parameter
+2. Agent instructions include domain-specific guidance
+3. Custom tool wrappers that inject domain context
+4. Shared memory for consistent domain context
+
+No core SDK changes required - uses only existing framework features.
+"""
+
+import os
+import requests
+import json
+import base64
+from dotenv import load_dotenv
+from qdrant_client import QdrantClient
+from praisonaiagents import Agent, Task, PraisonAIAgents, Memory
+
+# Load environment variables from .env.local
+if not load_dotenv(dotenv_path=".env.local"):
+    raise FileNotFoundError(".env.local file not found. Please ensure it exists in the working directory.")
+
+# API Keys
+api_keys = {
+    "WHOXY_API_KEY": os.getenv("WHOXY_API_KEY"),
+    "FOFA_API_KEY": os.getenv("FOFA_API_KEY"),
+    "API_NINJAS_KEY": os.getenv("API_NINJAS_KEY"),
+    "QDRANT_API_KEY": os.getenv("QDRANT_API_KEY"),
+}
+
+# Debug API Keys
+for key, value in api_keys.items():
+    if not value:
+        raise ValueError(f"Missing API key: {key}. Ensure it is set in the environment variables or .env.local.")
+
+# Qdrant Configuration
+qdrant_url = "https://d32d17dc-6b1d-4e13-9bb5-94a4d9f4b457.europe-west3-0.gcp.cloud.qdrant.io:6333"
+qdrant_client = QdrantClient(url=qdrant_url, api_key=api_keys["QDRANT_API_KEY"])
+
+# Domain Configuration - This is the key to solving the context issue
+class DomainContext:
+    def __init__(self, target_domain: str):
+        self.target_domain = target_domain
+        self.context_description = f"DOMAIN CONTEXT: All tool operations must focus exclusively on the domain '{target_domain}'. Never use example.com or any other domain."
+        
+    def get_context(self):
+        return {
+            "domain": self.target_domain,
+            "instructions": self.context_description,
+            "constraints": [f"Only analyze {self.target_domain}", "No generic examples", "Domain-specific results only"]
+        }
+
+# Initialize domain context
+domain = "eenadu.net"
+domain_context = DomainContext(domain)
+
+# SOLUTION 1: Custom Tool Wrappers with Domain Context Injection
+def create_domain_aware_tools(target_domain: str):
+    """Create domain-aware versions of tools that inject the target domain"""
+    
+    def query_fofa(query: str = None) -> dict:
+        # Use target domain if no specific query provided
+        if query is None or query == "example.com":
+            query = target_domain
+        # Ensure domain context is considered
+        enhanced_query = f"{target_domain} {query}" if target_domain not in query else query
+        
+        base64_query = base64.b64encode(enhanced_query.encode("utf-8")).decode("utf-8")
+        response = requests.get(
+            f"https://fofa.info/api/v1/search/all?key={api_keys['FOFA_API_KEY']}&qbase64={base64_query}&size=100&fields=jarm,host,domain,title,ip,port,protocol,base_protocol,country,country_name,region,city,longitude,latitude,as_number,as_organization,os,server,icp,header,banner,cert,link,certs_issuer_org,certs_issuer_cn,certs_subject_org,certs_subject_cn,tls_ja3s,tls_version"
+        )
+        return response.json()
+
+    def query_crtsh(domain_param: str = None) -> list:
+        # Use target domain if no specific domain provided
+        if domain_param is None or domain_param == "example.com":
+            domain_param = target_domain
+            
+        response = requests.get(f"https://crt.sh/?q={domain_param}&output=json")
+        return response.json()
+
+    def query_whoxy(email_or_org: str = None) -> dict:
+        # Use target domain if no specific parameter provided
+        if email_or_org is None or email_or_org == "example.com":
+            email_or_org = target_domain
+            
+        response = requests.get(
+            f"https://api.whoxy.com/?key={api_keys['WHOXY_API_KEY']}&reverse=whois&search={email_or_org}"
+        )
+        return response.json()
+
+    def query_api_ninjas(domain_param: str = None) -> dict:
+        # Use target domain if no specific domain provided
+        if domain_param is None or domain_param == "example.com":
+            domain_param = target_domain
+            
+        response = requests.get(
+            f"https://api.api-ninjas.com/v1/dnslookup?domain={domain_param}",
+            headers={"X-Api-Key": api_keys["API_NINJAS_KEY"]},
+        )
+        return response.json()
+
+    def query_networkcalc(domain_param: str = None) -> dict:
+        # Use target domain if no specific domain provided
+        if domain_param is None or domain_param == "example.com":
+            domain_param = target_domain
+            
+        response = requests.get(f"https://networkcalc.com/api/dns/lookup/{domain_param}")
+        return response.json()
+    
+    return [query_fofa, query_crtsh, query_whoxy, query_api_ninjas, query_networkcalc]
+
+# Create domain-aware tools
+domain_tools = create_domain_aware_tools(domain)
+
+def perform_reverse_lookups(domain: str, manager_memory: dict):
+    """Perform WHOXY lookups and store related domains."""
+    reverse_data = domain_tools[2](domain)  # Use domain-aware whoxy tool
+    email = reverse_data.get("email_address", "")
+    organization = reverse_data.get("organization_name", "")
+    owner = reverse_data.get("owner_name", "")
+
+    # Perform additional reverse lookups
+    related_by_email = domain_tools[2](email) if email else {}
+    related_by_org = domain_tools[2](organization) if organization else {}
+    related_by_owner = domain_tools[2](owner) if owner else {}
+
+    # Filter out unrelated domains
+    in_scope_domains = set()
+    for lookup_data in [related_by_email, related_by_org, related_by_owner]:
+        for domain_info in lookup_data.get("searchResult", {}).get("domains", []):
+            if domain in domain_info or is_in_scope(domain_info):
+                in_scope_domains.add(domain_info)
+
+    # Store results in memory
+    manager_memory["related_domains"] = list(in_scope_domains)
+
+def is_in_scope(domain: str) -> bool:
+    """Filter domains based on scope criteria."""
+    out_of_scope_keywords = ["example.com", "google.com", "microsoft.com", "cloudflare.com"]
+    return not any(keyword in domain for keyword in out_of_scope_keywords)
+
+# SOLUTION 2: Agents with Domain-Specific Instructions
+manager_agent = Agent(
+    name="Manager Agent",
+    role="Coordinate data collection and refinement",
+    goal=f"Collect user input, oversee tasks, and perform WHOXY lookups for related domains specifically for {domain}.",
+    backstory=f"Strategically manages all agents and ensures focused execution on the domain {domain}.",
+    instructions=f"""
+    CRITICAL DOMAIN CONTEXT: You are working exclusively with the domain '{domain}'. 
+    
+    All operations, tool calls, and analysis must focus on this specific domain.
+    When coordinating with other agents, ensure they understand the domain context.
+    Never use example.com or generic examples - always use {domain}.
+    
+    Your primary responsibility is to ensure all agents maintain focus on {domain} throughout the workflow.
+    """,
+    tools=[],
+    verbose=True,
+    llm="gpt-4o",
+    markdown=True,
+    memory={"short_term": {"target_domain": domain}, "long_term": qdrant_client},
+)
+
+tool_agent = Agent(
+    name="Tool Agent",
+    role="Run initial tool queries",
+    goal=f"Gather subdomains, DNS records, reverse WHOIS data, and FOFA data specifically for {domain}.",
+    backstory=f"Tool specialist focused exclusively on analyzing the domain {domain}. Expert in running information-gathering queries using all available tools.",
+    instructions=f"""
+    CRITICAL DOMAIN CONTEXT: Your exclusive focus is the domain '{domain}'.
+    
+    When using any tool:
+    1. Always use '{domain}' as the target domain
+    2. Never use example.com or any other domain
+    3. If a tool asks for a domain parameter, provide '{domain}'
+    4. If a tool asks for a query, include '{domain}' in the query
+    5. All searches and analysis must be domain-specific to '{domain}'
+    
+    Remember: You are a specialist for {domain} only. No generic examples or other domains.
+    """,
+    tools=domain_tools,  # Use domain-aware tools
+    verbose=True,
+    llm="gpt-4o",
+    markdown=True,
+    memory={"short_term": {"target_domain": domain}, "long_term": qdrant_client},
+)
+
+sr_pentester_agent = Agent(
+    name="Senior Pentester",
+    role="Analyze tool results for vulnerabilities",
+    goal=f"Investigate vulnerabilities and organize data for deep dives specifically for {domain}.",
+    backstory=f"An expert in penetration testing and data correlation with deep expertise in analyzing {domain}.",
+    instructions=f"""
+    CRITICAL DOMAIN CONTEXT: You are analyzing security findings for the domain '{domain}' exclusively.
+    
+    When reviewing tool results:
+    1. Focus only on findings related to '{domain}'
+    2. Filter out any results from other domains
+    3. Prioritize vulnerabilities specific to '{domain}'
+    4. Organize findings with '{domain}' as the central focus
+    
+    Your expertise is domain-specific to {domain}. All analysis must be relevant to this domain only.
+    """,
+    tools=[],
+    verbose=True,
+    llm="gpt-4o",
+    markdown=True,
+    memory={"short_term": {"target_domain": domain}, "long_term": qdrant_client},
+)
+
+ciso_agent = Agent(
+    name="CISO Agent",
+    role="Executive Security Analysis",
+    goal=f"Review findings and provide high-level recommendations specifically for {domain}.",
+    backstory=f"Provides strategic insights and ensures alignment with organizational goals for {domain} security posture.",
+    instructions=f"""
+    CRITICAL DOMAIN CONTEXT: You are providing executive security analysis for the domain '{domain}' exclusively.
+    
+    In your strategic recommendations:
+    1. Focus on security posture of '{domain}' only
+    2. Provide recommendations specific to '{domain}'
+    3. Consider business impact on '{domain}' operations
+    4. Align security strategy with '{domain}' organizational goals
+    
+    Your strategic insights must be domain-specific to {domain}. No generic recommendations.
+    """,
+    tools=[],
+    verbose=True,
+    llm="gpt-4o",
+    markdown=True,
+    memory={"short_term": {"target_domain": domain}, "long_term": qdrant_client},
+)
+
+# SOLUTION 3: Tasks with Domain Context Parameter
+tool_query_task = Task(
+    name="tool_query_task",
+    description=f"Run all tools to gather initial domain data for {domain}. Use the domain {domain} exclusively for all tool operations.",
+    expected_output=f"Raw data from all tools for the domain {domain} stored in Qdrant.",
+    agent=tool_agent,
+    context=[domain_context.get_context()]  # Pass domain context to task
+)
+
+pentester_analysis_task = Task(
+    name="pentester_analysis_task",
+    description=f"Analyze tool output for vulnerabilities and prioritize areas of focus for the domain {domain}.",
+    expected_output=f"Organized and prioritized security findings for {domain} stored in Qdrant.",
+    agent=sr_pentester_agent,
+    context=[domain_context.get_context(), tool_query_task]  # Include domain context and previous task
+)
+
+ciso_review_task = Task(
+    name="ciso_review_task",
+    description=f"Review pentester findings and provide strategic recommendations for the domain {domain}.",
+    expected_output=f"High-level executive security recommendations for {domain} stored in Qdrant.",
+    agent=ciso_agent,
+    context=[domain_context.get_context(), pentester_analysis_task]  # Include domain context and previous task
+)
+
+# SOLUTION 4: Agents with Shared Memory Configuration
+agents = PraisonAIAgents(
+    agents=[manager_agent, tool_agent, sr_pentester_agent, ciso_agent],
+    tasks=[tool_query_task, pentester_analysis_task, ciso_review_task],
+    verbose=True,
+    process="hierarchical",
+    manager_llm="gpt-4o",
+    memory=True,  # Enable shared memory for domain context
+    memory_config={
+        "provider": "rag",
+        "config": {
+            "collection_name": f"{domain.replace('.', '_')}_security_analysis"
+        }
+    }
+)
+
+# Main Execution Workflow
+def main():
+    print(f"Welcome to the Hierarchical Pentesting Workflow for {domain}!")
+    
+    # Store domain context in memory for all agents
+    domain_info = f"Target domain for analysis: {domain}. All operations must focus on this domain exclusively."
+    
+    # Initialize shared context for all agents
+    for agent in [manager_agent, tool_agent, sr_pentester_agent, ciso_agent]:
+        agent.memory["short_term"]["domain_context"] = domain_context.get_context()
+        agent.memory["short_term"]["target_domain"] = domain
+    
+    print(f"Domain context initialized: {domain}")
+    print(f"All agents configured to focus exclusively on: {domain}")
+    
+    # Execute the workflow
+    result = agents.start()
+
+    # Serialize TaskOutput to JSON-serializable format
+    serialized_result = []
+    for task in agents.tasks:
+        if hasattr(task, "name") and hasattr(task, "output"):
+            serialized_result.append({
+                "task_name": task.name,
+                "domain": domain,
+                "output": task.output.to_dict() if hasattr(task.output, "to_dict") else str(task.output),
+            })
+        else:
+            print(f"Skipping task: {task} due to missing attributes.")
+
+    # Output results
+    print(f"Workflow Results for {domain}:")
+    print(json.dumps(serialized_result, indent=4))
+    
+    # Verify domain context was maintained
+    print(f"\nDomain Context Verification:")
+    print(f"Target Domain: {domain}")
+    print(f"Context properly maintained: {'YES' if all('target_domain' in agent.memory['short_term'] for agent in agents.agents) else 'NO'}")
+
+if __name__ == "__main__":
+    main()

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -16,7 +16,8 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     client,
-    adisplay_instruction
+    adisplay_instruction,
+    approval_callback
 )
 import inspect
 import uuid
@@ -570,6 +571,35 @@ Your Goal: {self.goal}
         """
         logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
 
+        # Check if approval is required for this tool
+        from ..approval import is_approval_required, console_approval_callback, get_risk_level, mark_approved, ApprovalDecision
+        if is_approval_required(function_name):
+            risk_level = get_risk_level(function_name)
+            logging.info(f"Tool {function_name} requires approval (risk level: {risk_level})")
+            
+            # Use global approval callback or default console callback
+            callback = approval_callback or console_approval_callback
+            
+            try:
+                decision = callback(function_name, arguments, risk_level)
+                if not decision.approved:
+                    error_msg = f"Tool execution denied: {decision.reason}"
+                    logging.warning(error_msg)
+                    return {"error": error_msg, "approval_denied": True}
+                
+                # Mark as approved in context to prevent double approval in decorator
+                mark_approved(function_name)
+                
+                # Use modified arguments if provided
+                if decision.modified_args:
+                    arguments = decision.modified_args
+                    logging.info(f"Using modified arguments: {arguments}")
+                    
+            except Exception as e:
+                error_msg = f"Error during approval process: {str(e)}"
+                logging.error(error_msg)
+                return {"error": error_msg, "approval_error": True}
+
         # Special handling for MCP tools
         # Check if tools is an MCP instance with the requested function name
         from ..mcp.mcp import MCP
@@ -1418,6 +1448,21 @@ Your Goal: {self.goal}
         """Async version of execute_tool"""
         try:
             logging.info(f"Executing async tool: {function_name} with arguments: {arguments}")
+            
+            # Check if approval is required for this tool
+            from ..approval import is_approval_required, request_approval
+            if is_approval_required(function_name):
+                decision = await request_approval(function_name, arguments)
+                if not decision.approved:
+                    error_msg = f"Tool execution denied: {decision.reason}"
+                    logging.warning(error_msg)
+                    return {"error": error_msg, "approval_denied": True}
+                
+                # Use modified arguments if provided
+                if decision.modified_args:
+                    arguments = decision.modified_args
+                    logging.info(f"Using modified arguments: {arguments}")
+            
             # Try to find the function in the agent's tools list first
             func = None
             for tool in self.tools:

src/praisonai-agents/praisonaiagents/approval.py

@@ -0,0 +1,263 @@
+"""
+Human Approval Framework for PraisonAI Agents
+
+This module provides a minimal human-in-the-loop approval system for dangerous tool operations.
+It extends the existing callback system to require human approval before executing high-risk tools.
+"""
+
+import logging
+import asyncio
+from typing import Dict, Set, Optional, Callable, Any, Literal
+from functools import wraps
+from contextvars import ContextVar
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.prompt import Confirm
+
+# Global registries for approval requirements
+APPROVAL_REQUIRED_TOOLS: Set[str] = set()
+TOOL_RISK_LEVELS: Dict[str, str] = {}
+
+# Risk levels
+RiskLevel = Literal["critical", "high", "medium", "low"]
+
+# Global approval callback
+approval_callback: Optional[Callable] = None
+
+# Context variable to track if we're in an approved execution context
+_approved_context: ContextVar[Set[str]] = ContextVar('approved_context', default=set())
+
+class ApprovalDecision:
+    """Result of an approval request"""
+    def __init__(self, approved: bool, modified_args: Optional[Dict[str, Any]] = None, reason: str = ""):
+        self.approved = approved
+        self.modified_args = modified_args or {}
+        self.reason = reason
+
+def set_approval_callback(callback_fn: Callable):
+    """Set a custom approval callback function.
+    
+    The callback should accept (function_name, arguments, risk_level) and return ApprovalDecision.
+    """
+    global approval_callback
+    approval_callback = callback_fn
+
+def mark_approved(tool_name: str):
+    """Mark a tool as approved in the current context."""
+    approved = _approved_context.get(set())
+    approved.add(tool_name)
+    _approved_context.set(approved)
+
+def is_already_approved(tool_name: str) -> bool:
+    """Check if a tool is already approved in the current context."""
+    approved = _approved_context.get(set())
+    return tool_name in approved
+
+def clear_approval_context():
+    """Clear the approval context."""
+    _approved_context.set(set())
+
+def require_approval(risk_level: RiskLevel = "high"):
+    """Decorator to mark a tool as requiring human approval.
+    
+    Args:
+        risk_level: The risk level of the tool ("critical", "high", "medium", "low")
+    """
+    def decorator(func):
+        tool_name = getattr(func, '__name__', str(func))
+        APPROVAL_REQUIRED_TOOLS.add(tool_name)
+        TOOL_RISK_LEVELS[tool_name] = risk_level
+        
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Skip approval if already approved in current context
+            if is_already_approved(tool_name):
+                return func(*args, **kwargs)
+            
+            # Request approval before executing the function
+            try:
+                # Try to check if we're in an async context
+                try:
+                    asyncio.get_running_loop()
+                    # We're in an async context, but this is a sync function
+                    # Fall back to sync approval to avoid loop conflicts
+                    raise RuntimeError("Use sync fallback in async context")
+                except RuntimeError:
+                    # Either no running loop or we want sync fallback
+                    # Use asyncio.run for clean async execution
+                    decision = asyncio.run(request_approval(tool_name, kwargs))
+            except Exception as e:
+                # Fallback to sync approval if async fails
+                logging.warning(f"Async approval failed, using sync fallback: {e}")
+                callback = approval_callback or console_approval_callback
+                decision = callback(tool_name, kwargs, risk_level)
+            
+            if not decision.approved:
+                raise PermissionError(f"Execution of {tool_name} denied: {decision.reason}")
+            
+            # Mark as approved and merge modified args
+            mark_approved(tool_name)
+            kwargs.update(decision.modified_args)
+            return func(*args, **kwargs)
+        
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            # Skip approval if already approved in current context
+            if is_already_approved(tool_name):
+                return await func(*args, **kwargs)
+            
+            # Request approval before executing the function
+            decision = await request_approval(tool_name, kwargs)
+            if not decision.approved:
+                raise PermissionError(f"Execution of {tool_name} denied: {decision.reason}")
+            
+            # Mark as approved and merge modified args
+            mark_approved(tool_name)
+            kwargs.update(decision.modified_args)
+            return await func(*args, **kwargs)
+        
+        # Return the appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return wrapper
+    
+    return decorator
+
+def console_approval_callback(function_name: str, arguments: Dict[str, Any], risk_level: str) -> ApprovalDecision:
+    """Default console-based approval callback.
+    
+    Displays tool information and prompts user for approval via console.
+    """
+    console = Console()
+    
+    # Create risk level styling
+    risk_colors = {
+        "critical": "bold red",
+        "high": "red", 
+        "medium": "yellow",
+        "low": "blue"
+    }
+    risk_color = risk_colors.get(risk_level, "white")
+    
+    # Display tool information
+    tool_info = f"[bold]Function:[/] {function_name}\n"
+    tool_info += f"[bold]Risk Level:[/] [{risk_color}]{risk_level.upper()}[/{risk_color}]\n"
+    tool_info += f"[bold]Arguments:[/]\n"
+    
+    for key, value in arguments.items():
+        # Truncate long values for display
+        str_value = str(value)
+        if len(str_value) > 100:
+            str_value = str_value[:97] + "..."
+        tool_info += f"  {key}: {str_value}\n"
+    
+    console.print(Panel(
+        tool_info.strip(),
+        title="🔒 Tool Approval Required",
+        border_style=risk_color,
+        title_align="left"
+    ))
+    
+    # Get user approval
+    try:
+        approved = Confirm.ask(
+            f"[{risk_color}]Do you want to execute this {risk_level} risk tool?[/{risk_color}]",
+            default=False
+        )
+        
+        if approved:
+            console.print("[green]✅ Tool execution approved[/green]")
+            return ApprovalDecision(approved=True, reason="User approved")
+        else:
+            console.print("[red]❌ Tool execution denied[/red]")
+            return ApprovalDecision(approved=False, reason="User denied")
+            
+    except KeyboardInterrupt:
+        console.print("\n[red]❌ Tool execution cancelled by user[/red]")
+        return ApprovalDecision(approved=False, reason="User cancelled")
+    except Exception as e:
+        console.print(f"[red]Error during approval: {e}[/red]")
+        return ApprovalDecision(approved=False, reason=f"Approval error: {e}")
+
+async def request_approval(function_name: str, arguments: Dict[str, Any]) -> ApprovalDecision:
+    """Request approval for a tool execution.
+    
+    Args:
+        function_name: Name of the function to execute
+        arguments: Arguments to pass to the function
+        
+    Returns:
+        ApprovalDecision with approval status and any modifications
+    """
+    # Check if approval is required
+    if function_name not in APPROVAL_REQUIRED_TOOLS:
+        return ApprovalDecision(approved=True, reason="No approval required")
+    
+    risk_level = TOOL_RISK_LEVELS.get(function_name, "medium")
+    
+    # Use custom callback if set, otherwise use console callback
+    callback = approval_callback or console_approval_callback
+    
+    try:
+        # Handle async callbacks
+        if asyncio.iscoroutinefunction(callback):
+            decision = await callback(function_name, arguments, risk_level)
+        else:
+            # Run sync callback in executor to avoid blocking
+            loop = asyncio.get_event_loop()
+            decision = await loop.run_in_executor(None, callback, function_name, arguments, risk_level)
+        
+        return decision
+        
+    except Exception as e:
+        logging.error(f"Error in approval callback: {e}")
+        return ApprovalDecision(approved=False, reason=f"Approval callback error: {e}")
+
+# Default dangerous tools - can be configured at runtime
+DEFAULT_DANGEROUS_TOOLS = {
+    # Critical risk tools
+    "execute_command": "critical",
+    "kill_process": "critical", 
+    "execute_code": "critical",
+    
+    # High risk tools
+    "write_file": "high",
+    "delete_file": "high",
+    "move_file": "high",
+    "copy_file": "high",
+    "execute_query": "high",
+    
+    # Medium risk tools
+    "evaluate": "medium",
+    "crawl": "medium",
+    "scrape_page": "medium",
+}
+
+def configure_default_approvals():
+    """Configure default dangerous tools to require approval."""
+    for tool_name, risk_level in DEFAULT_DANGEROUS_TOOLS.items():
+        APPROVAL_REQUIRED_TOOLS.add(tool_name)
+        TOOL_RISK_LEVELS[tool_name] = risk_level
+
+def add_approval_requirement(tool_name: str, risk_level: RiskLevel = "high"):
+    """Dynamically add approval requirement for a tool."""
+    APPROVAL_REQUIRED_TOOLS.add(tool_name)
+    TOOL_RISK_LEVELS[tool_name] = risk_level
+
+def remove_approval_requirement(tool_name: str):
+    """Remove approval requirement for a tool."""
+    APPROVAL_REQUIRED_TOOLS.discard(tool_name)
+    TOOL_RISK_LEVELS.pop(tool_name, None)
+
+def is_approval_required(tool_name: str) -> bool:
+    """Check if a tool requires approval."""
+    return tool_name in APPROVAL_REQUIRED_TOOLS
+
+def get_risk_level(tool_name: str) -> Optional[str]:
+    """Get the risk level of a tool."""
+    return TOOL_RISK_LEVELS.get(tool_name)
+
+# Initialize with defaults
+configure_default_approvals()

src/praisonai-agents/praisonaiagents/knowledge/knowledge.py

@@ -17,9 +17,13 @@ class CustomMemory:
         }).from_config(config)
 
     @staticmethod
-    def _add_to_vector_store(self, messages, metadata, filters, infer):
+    def _add_to_vector_store(self, messages, metadata=None, filters=None, infer=None):
         # Custom implementation that doesn't use LLM
-        parsed_messages = "\n".join([msg["content"] for msg in messages])
+        # Handle different message formats for backward compatibility
+        if isinstance(messages, list):
+            parsed_messages = "\n".join([msg.get("content", str(msg)) if isinstance(msg, dict) else str(msg) for msg in messages])
+        else:
+            parsed_messages = str(messages)
         
         # Create a simple fact without using LLM
         new_retrieved_facts = [parsed_messages]
@@ -34,7 +38,7 @@ class CustomMemory:
         memory_id = self._create_memory(
             data=parsed_messages,
             existing_embeddings=new_message_embeddings,
-            metadata=metadata
+            metadata=metadata or {}
         )
         
         return [{
@@ -137,6 +141,10 @@ class Knowledge:
             # Merge reranker config if provided
             if "reranker" in self._config:
                 base_config["reranker"].update(self._config["reranker"])
+            
+            # Merge graph_store config if provided (for graph memory support)
+            if "graph_store" in self._config:
+                base_config["graph_store"] = self._config["graph_store"]
         return base_config
 
     @cached_property
@@ -184,7 +192,22 @@ class Knowledge:
                 if not content:
                     return []
                 
-            result = self.memory.add(content, user_id=user_id, agent_id=agent_id, run_id=run_id, metadata=metadata)
+            # Try new API format first, fall back to old format for backward compatibility
+            try:
+                # Convert content to messages format for mem0 API compatibility
+                if isinstance(content, str):
+                    messages = [{"role": "user", "content": content}]
+                else:
+                    messages = content if isinstance(content, list) else [{"role": "user", "content": str(content)}]
+                
+                result = self.memory.add(messages=messages, user_id=user_id, agent_id=agent_id, run_id=run_id, metadata=metadata)
+            except TypeError as e:
+                # Fallback to old API format if messages parameter is not supported
+                if "unexpected keyword argument" in str(e) or "positional argument" in str(e):
+                    self._log(f"Falling back to legacy API format due to: {e}")
+                    result = self.memory.add(content, user_id=user_id, agent_id=agent_id, run_id=run_id, metadata=metadata)
+                else:
+                    raise
             self._log(f"Store operation result: {result}")
             return result
         except Exception as e:

src/praisonai-agents/praisonaiagents/llm/llm.py

@@ -1512,6 +1512,10 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         if self.stop_phrases:
             params["stop"] = self.stop_phrases
         
+        # Add extra settings for provider-specific parameters (e.g., num_ctx for Ollama)
+        if self.extra_settings:
+            params.update(self.extra_settings)
+        
         # Override with any provided parameters
         params.update(override_params)
         

src/praisonai-agents/praisonaiagents/main.py

@@ -43,12 +43,18 @@ error_logs = []
 sync_display_callbacks = {}
 async_display_callbacks = {}
 
+# Global approval callback registry
+approval_callback = None
+
 # At the top of the file, add display_callbacks to __all__
 __all__ = [
     'error_logs',
     'register_display_callback',
+    'register_approval_callback',
     'sync_display_callbacks',
     'async_display_callbacks',
+    'execute_callback',
+    'approval_callback',
     # ... other exports
 ]
 
@@ -65,6 +71,15 @@ def register_display_callback(display_type: str, callback_fn, is_async: bool = F
     else:
         sync_display_callbacks[display_type] = callback_fn
 
+def register_approval_callback(callback_fn):
+    """Register a global approval callback function for dangerous tool operations.
+    
+    Args:
+        callback_fn: Function that takes (function_name, arguments, risk_level) and returns ApprovalDecision
+    """
+    global approval_callback
+    approval_callback = callback_fn
+
 async def execute_callback(display_type: str, **kwargs):
     """Execute both sync and async callbacks for a given display type.
     

src/praisonai-agents/praisonaiagents/memory/memory.py

@@ -41,6 +41,7 @@ class Memory:
     - User memory (preferences/history for each user)
     - Quality score logic for deciding which data to store in LTM
     - Context building from multiple memory sources
+    - Graph memory support for complex relationship storage (via Mem0)
 
     Config example:
     {
@@ -53,9 +54,35 @@ class Memory:
         "api_key": "...",       # if mem0 usage
         "org_id": "...",
         "project_id": "...",
-        ...
+        
+        # Graph memory configuration (optional)
+        "graph_store": {
+          "provider": "neo4j" or "memgraph",
+          "config": {
+            "url": "neo4j+s://xxx" or "bolt://localhost:7687",
+            "username": "neo4j" or "memgraph",
+            "password": "xxx"
+          }
+        },
+        
+        # Optional additional configurations for graph memory
+        "vector_store": {
+          "provider": "qdrant",
+          "config": {"host": "localhost", "port": 6333}
+        },
+        "llm": {
+          "provider": "openai",
+          "config": {"model": "gpt-4o", "api_key": "..."}
+        },
+        "embedder": {
+          "provider": "openai",
+          "config": {"model": "text-embedding-3-small", "api_key": "..."}
+        }
       }
     }
+    
+    Note: Graph memory requires "mem0ai[graph]" installation and works alongside 
+    vector-based memory for enhanced relationship-aware retrieval.
     """
 
     def __init__(self, config: Dict[str, Any], verbose: int = 0):
@@ -78,6 +105,7 @@ class Memory:
         self.provider = self.cfg.get("provider", "rag")
         self.use_mem0 = (self.provider.lower() == "mem0") and MEM0_AVAILABLE
         self.use_rag = (self.provider.lower() == "rag") and CHROMADB_AVAILABLE and self.cfg.get("use_embedding", False)
+        self.graph_enabled = False  # Initialize graph support flag
 
         # Create .praison directory if it doesn't exist
         os.makedirs(".praison", exist_ok=True)
@@ -137,16 +165,49 @@ class Memory:
         conn.close()
 
     def _init_mem0(self):
-        """Initialize Mem0 client for agent or user memory."""
-        from mem0 import MemoryClient
+        """Initialize Mem0 client for agent or user memory with optional graph support."""
         mem_cfg = self.cfg.get("config", {})
         api_key = mem_cfg.get("api_key", os.getenv("MEM0_API_KEY"))
         org_id = mem_cfg.get("org_id")
         proj_id = mem_cfg.get("project_id")
-        if org_id and proj_id:
-            self.mem0_client = MemoryClient(api_key=api_key, org_id=org_id, project_id=proj_id)
+        
+        # Check if graph memory is enabled
+        graph_config = mem_cfg.get("graph_store")
+        use_graph = graph_config is not None
+        
+        if use_graph:
+            # Initialize with graph memory support
+            from mem0 import Memory
+            self._log_verbose("Initializing Mem0 with graph memory support")
+            
+            # Build Mem0 config with graph store
+            mem0_config = {}
+            
+            # Add graph store configuration
+            mem0_config["graph_store"] = graph_config
+            
+            # Add other configurations if provided
+            if "vector_store" in mem_cfg:
+                mem0_config["vector_store"] = mem_cfg["vector_store"]
+            if "llm" in mem_cfg:
+                mem0_config["llm"] = mem_cfg["llm"]
+            if "embedder" in mem_cfg:
+                mem0_config["embedder"] = mem_cfg["embedder"]
+            
+            # Initialize Memory with graph support
+            self.mem0_client = Memory.from_config(config_dict=mem0_config)
+            self.graph_enabled = True
+            self._log_verbose("Graph memory initialized successfully")
         else:
-            self.mem0_client = MemoryClient(api_key=api_key)
+            # Use traditional MemoryClient
+            from mem0 import MemoryClient
+            self._log_verbose("Initializing Mem0 with traditional memory client")
+            
+            if org_id and proj_id:
+                self.mem0_client = MemoryClient(api_key=api_key, org_id=org_id, project_id=proj_id)
+            else:
+                self.mem0_client = MemoryClient(api_key=api_key)
+            self.graph_enabled = False
 
     def _init_chroma(self):
         """Initialize a local Chroma client for embedding-based search."""

src/praisonai-agents/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.

src/praisonai-agents/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,

src/praisonai-agents/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,

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.95"
+version = "0.0.96"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [
@@ -35,6 +35,12 @@ knowledge = [
     "chonkie>=1.0.2"
 ]
 
+# Graph memory support (includes Mem0 with graph capabilities)
+graph = [
+    "mem0ai[graph]>=0.1.0",
+    "chromadb>=1.0.0"
+]
+
 # Add LLM dependencies
 llm = [
     "litellm>=1.50.0",
@@ -51,6 +57,7 @@ api = [
 all = [
     "praisonaiagents[memory]",
     "praisonaiagents[knowledge]",
+    "praisonaiagents[graph]",
     "praisonaiagents[llm]",
     "praisonaiagents[mcp]",
     "praisonaiagents[api]"

src/praisonai-agents/requirements.txt

@@ -11,5 +11,9 @@ mem0ai>=0.1.0
 markitdown
 chonkie>=1.0.2
 
+# Graph memory dependencies (optional)
+# Uncomment for graph memory support:
+# mem0ai[graph]>=0.1.0
+
 # Development dependencies
 python-dotenv>=0.19.0

src/praisonai-agents/tests/test-graph-memory.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Test script for graph memory functionality
+"""
+
+from praisonaiagents.memory import Memory
+from praisonaiagents.knowledge import Knowledge
+
+def test_memory_graph_config():
+    """Test memory with graph configuration"""
+    print("Testing Memory with graph configuration...")
+    
+    # Configuration with graph store
+    config = {
+        "provider": "mem0",
+        "config": {
+            "graph_store": {
+                "provider": "memgraph",
+                "config": {
+                    "url": "bolt://localhost:7687",
+                    "username": "memgraph",
+                    "password": ""
+                }
+            },
+            "vector_store": {
+                "provider": "chroma",
+                "config": {"path": ".test_graph_memory"}
+            }
+        }
+    }
+    
+    try:
+        memory = Memory(config=config, verbose=1)
+        print(f"✅ Memory initialized. Graph enabled: {getattr(memory, 'graph_enabled', False)}")
+        
+        # Test basic memory operations
+        memory.store_short_term("Alice loves hiking", {"category": "preference"})
+        memory.store_short_term("Alice's friend John also loves hiking", {"category": "social"})
+        
+        results = memory.search_short_term("hiking", limit=2)
+        print(f"✅ Short-term search returned {len(results)} results")
+        
+        return True
+        
+    except Exception as e:
+        print(f"⚠️  Graph memory test failed (expected if dependencies missing): {e}")
+        return False
+
+def test_knowledge_graph_config():
+    """Test Knowledge with graph configuration"""
+    print("\nTesting Knowledge with graph configuration...")
+    
+    config = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "test_graph_knowledge",
+                "path": ".test_graph_knowledge"
+            }
+        },
+        "graph_store": {
+            "provider": "memgraph",
+            "config": {
+                "url": "bolt://localhost:7687",
+                "username": "memgraph",
+                "password": ""
+            }
+        }
+    }
+    
+    try:
+        knowledge = Knowledge(config=config, verbose=0)
+        final_config = knowledge.config
+        
+        if "graph_store" in final_config:
+            print("✅ Graph store configuration preserved in Knowledge")
+        else:
+            print("❌ Graph store configuration missing")
+            
+        return True
+        
+    except Exception as e:
+        print(f"⚠️  Knowledge graph test failed: {e}")
+        return False
+
+def test_backward_compatibility():
+    """Test that existing configurations still work"""
+    print("\nTesting backward compatibility...")
+    
+    # Old-style configuration without graph
+    old_config = {
+        "provider": "mem0",
+        "config": {
+            "vector_store": {
+                "provider": "chroma",
+                "config": {"path": ".test_backward_compat"}
+            }
+        }
+    }
+    
+    try:
+        memory = Memory(config=old_config, verbose=0)
+        print("✅ Backward compatibility maintained")
+        print(f"   Graph enabled: {getattr(memory, 'graph_enabled', False)}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Backward compatibility broken: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Graph Memory Integration Tests")
+    print("=" * 50)
+    
+    tests = [
+        test_memory_graph_config,
+        test_knowledge_graph_config,
+        test_backward_compatibility
+    ]
+    
+    passed = 0
+    for test in tests:
+        if test():
+            passed += 1
+    
+    print(f"\n📊 Results: {passed}/{len(tests)} tests passed")
+    
+    if passed == len(tests):
+        print("🎉 All tests passed!")
+    else:
+        print("⚠️  Some tests failed. This is expected if graph dependencies are not installed.")
+    
+    print("\n💡 To enable full graph memory functionality:")
+    print("   pip install \"mem0ai[graph]\"")
+    print("   docker run -p 7687:7687 memgraph/memgraph-mage:latest")

src/praisonai-agents/uv.lock

@@ -2233,7 +2233,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.95"
+version = "0.0.96"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.24.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.24.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.25.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.25.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.2.24 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.25 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/praisonai/ui/chat.py

@@ -12,7 +12,7 @@ import base64
 from dotenv import load_dotenv
 from PIL import Image
 from tavily import TavilyClient
-from crawl4ai import AsyncAsyncWebCrawler
+from crawl4ai import AsyncWebCrawler
 
 # Local application/library imports
 import chainlit as cl

src/praisonai/praisonai/ui/code.py

@@ -12,7 +12,7 @@ from dotenv import load_dotenv
 from PIL import Image
 from context import ContextGatherer
 from tavily import TavilyClient
-from crawl4ai import AsyncAsyncWebCrawler
+from crawl4ai import AsyncWebCrawler
 
 # Local application/library imports
 import chainlit as cl

src/praisonai/praisonai/ui/realtime.py

@@ -229,7 +229,7 @@ except Exception as e:
 @cl.on_chat_start
 async def start():
     initialize_db()
-    model_name = load_setting("model_name") or os.getenv("MODEL_NAME", "gpt-4o-mini-realtime-preview")
+    model_name = os.getenv("MODEL_NAME", "gpt-4o-mini-realtime-preview-2024-12-17")
     cl.user_session.set("model_name", model_name)
     cl.user_session.set("message_history", [])  # Initialize message history
     logger.debug(f"Model name: {model_name}")
@@ -238,7 +238,7 @@ async def start():
     #         TextInput(
     #             id="model_name",
     #             label="Enter the Model Name",
-    #             placeholder="e.g., gpt-4o-mini-realtime-preview",
+    #             placeholder="e.g., gpt-4o-mini-realtime-preview-2024-12-17",
     #             initial=model_name
     #         )
     #     ]
@@ -382,7 +382,8 @@ async def on_audio_start():
             openai_realtime = cl.user_session.get("openai_realtime")
         
         if not openai_realtime.is_connected():
-            await openai_realtime.connect()
+            model_name = cl.user_session.get("model_name", "gpt-4o-mini-realtime-preview-2024-12-17")
+            await openai_realtime.connect(model_name)
             
         logger.info("Connected to OpenAI realtime")
         return True
@@ -394,11 +395,22 @@ async def on_audio_start():
 
 @cl.on_audio_chunk
 async def on_audio_chunk(chunk: cl.InputAudioChunk):
-    openai_realtime: RealtimeClient = cl.user_session.get("openai_realtime")            
+    openai_realtime: RealtimeClient = cl.user_session.get("openai_realtime")
+    
+    if not openai_realtime:
+        logger.debug("No realtime client available")
+        return
+        
     if openai_realtime.is_connected():
-        await openai_realtime.append_input_audio(chunk.data)
+        try:
+            success = await openai_realtime.append_input_audio(chunk.data)
+            if not success:
+                logger.debug("Failed to append audio data - connection may be lost")
+        except Exception as e:
+            logger.debug(f"Error processing audio chunk: {e}")
+            # Optionally try to reconnect here if needed
     else:
-        logger.info("RealtimeClient is not connected")
+        logger.debug("RealtimeClient is not connected - audio chunk ignored")
 
 @cl.on_audio_end
 @cl.on_chat_end
@@ -423,14 +435,14 @@ def auth_callback(username: str, password: str):
 @cl.on_chat_resume
 async def on_chat_resume(thread: ThreadDict):
     logger.info(f"Resuming chat: {thread['id']}")
-    model_name = load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini-realtime-preview"
+    model_name = os.getenv("MODEL_NAME") or "gpt-4o-mini-realtime-preview-2024-12-17"
     logger.debug(f"Model name: {model_name}")
     settings = cl.ChatSettings(
         [
             TextInput(
                 id="model_name",
                 label="Enter the Model Name",
-                placeholder="e.g., gpt-4o-mini-realtime-preview",
+                placeholder="e.g., gpt-4o-mini-realtime-preview-2024-12-17",
                 initial=model_name
             )
         ]

src/praisonai/praisonai/ui/realtimeclient/__init__.py

@@ -6,6 +6,7 @@ import inspect
 import numpy as np
 import json
 import websockets
+from websockets.exceptions import ConnectionClosed
 from datetime import datetime
 from collections import defaultdict
 import base64
@@ -97,29 +98,66 @@ class RealtimeAPI(RealtimeEventHandler):
         self.ws = None
 
     def is_connected(self):
-        return self.ws is not None
+        if self.ws is None:
+            return False
+        # Some websockets versions don't have a closed attribute
+        try:
+            return not self.ws.closed
+        except AttributeError:
+            # Fallback: check if websocket is still alive by checking state
+            try:
+                return hasattr(self.ws, 'state') and self.ws.state.name == 'OPEN'
+            except:
+                # Last fallback: assume connected if ws exists
+                return True
 
     def log(self, *args):
         logger.debug(f"[Websocket/{datetime.utcnow().isoformat()}]", *args)
 
-    async def connect(self, model='gpt-4o-realtime-preview-2024-10-01'):
+    async def connect(self, model='gpt-4o-mini-realtime-preview-2024-12-17'):
         if self.is_connected():
             raise Exception("Already connected")
-        self.ws = await websockets.connect(f"{self.url}?model={model}", extra_headers={
+        
+        headers = {
             'Authorization': f'Bearer {self.api_key}',
             'OpenAI-Beta': 'realtime=v1'
-        })
+        }
+        
+        # Try different header parameter names for compatibility
+        try:
+            self.ws = await websockets.connect(f"{self.url}?model={model}", additional_headers=headers)
+        except TypeError:
+            # Fallback to older websockets versions
+            try:
+                self.ws = await websockets.connect(f"{self.url}?model={model}", extra_headers=headers)
+            except TypeError:
+                # Last fallback - some versions might not support headers parameter
+                raise Exception("Websockets library version incompatible. Please update websockets to version 11.0 or higher.")
+        
         self.log(f"Connected to {self.url}")
         asyncio.create_task(self._receive_messages())
 
     async def _receive_messages(self):
-        async for message in self.ws:
-            event = json.loads(message)
-            if event['type'] == "error":
-                logger.error("ERROR", event)
-            self.log("received:", event)
-            self.dispatch(f"server.{event['type']}", event)
-            self.dispatch("server.*", event)
+        try:
+            async for message in self.ws:
+                event = json.loads(message)
+                if event['type'] == "error":
+                    logger.error(f"OpenAI Realtime API Error: {event}")
+                self.log("received:", event)
+                self.dispatch(f"server.{event['type']}", event)
+                self.dispatch("server.*", event)
+        except ConnectionClosed as e:
+            logger.info(f"WebSocket connection closed normally: {e}")
+            # Mark connection as closed
+            self.ws = None
+            # Dispatch disconnection event
+            self.dispatch("disconnected", {"reason": str(e)})
+        except Exception as e:
+            logger.warning(f"WebSocket receive loop ended: {e}")
+            # Mark connection as closed
+            self.ws = None
+            # Dispatch disconnection event
+            self.dispatch("disconnected", {"reason": str(e)})
 
     async def send(self, event_name, data=None):
         if not self.is_connected():
@@ -135,16 +173,33 @@ class RealtimeAPI(RealtimeEventHandler):
         self.dispatch(f"client.{event_name}", event)
         self.dispatch("client.*", event)
         self.log("sent:", event)
-        await self.ws.send(json.dumps(event))
+        
+        try:
+            await self.ws.send(json.dumps(event))
+        except ConnectionClosed as e:
+            logger.info(f"WebSocket connection closed during send: {e}")
+            # Mark connection as closed if send fails
+            self.ws = None
+            raise Exception(f"WebSocket connection lost: {e}")
+        except Exception as e:
+            logger.error(f"Failed to send WebSocket message: {e}")
+            # Mark connection as closed if send fails
+            self.ws = None
+            raise Exception(f"WebSocket connection lost: {e}")
 
     def _generate_id(self, prefix):
         return f"{prefix}{int(datetime.utcnow().timestamp() * 1000)}"
 
     async def disconnect(self):
         if self.ws:
-            await self.ws.close()
-            self.ws = None
-            self.log(f"Disconnected from {self.url}")
+            try:
+                await self.ws.close()
+                logger.info(f"Disconnected from {self.url}")
+            except Exception as e:
+                logger.warning(f"Error during WebSocket close: {e}")
+            finally:
+                self.ws = None
+                self.log(f"WebSocket connection cleaned up")
 
 class RealtimeConversation:
     default_frequency = config.features.audio.sample_rate
@@ -341,8 +396,7 @@ class RealtimeConversation:
             return None, None
         array_buffer = base64_to_array_buffer(delta)
         append_values = array_buffer.tobytes()
-        # TODO: make it work
-        # item['formatted']['audio'] = merge_int16_arrays(item['formatted']['audio'], append_values)
+        item['formatted']['audio'].append(append_values)
         return item, {'audio': append_values}
 
     def _process_text_delta(self, event):
@@ -381,7 +435,6 @@ class RealtimeClient(RealtimeEventHandler):
             "tools": [],
             "tool_choice": "auto",
             "temperature": 0.8,
-            "max_response_output_tokens": 4096,
         }
         self.session_config = {}
         self.transcription_models = [{"model": "whisper-1"}]
@@ -431,8 +484,13 @@ class RealtimeClient(RealtimeEventHandler):
         self.dispatch("realtime.event", realtime_event)
 
     def _on_session_created(self, event):
-        print(f"Session created: {event}")
-        logger.debug(f"Session created: {event}")
+        try:
+            session_id = event.get('session', {}).get('id', 'unknown')
+            model = event.get('session', {}).get('model', 'unknown')
+            logger.info(f"OpenAI Realtime session created - ID: {session_id}, Model: {model}")
+        except Exception as e:
+            logger.warning(f"Error processing session created event: {e}")
+            logger.debug(f"Session event details: {event}")
         self.session_created = True
 
     def _process_event(self, event, *args):
@@ -497,10 +555,15 @@ class RealtimeClient(RealtimeEventHandler):
         self._add_api_event_handlers()
         return True
 
-    async def connect(self):
+    async def connect(self, model=None):
         if self.is_connected():
             raise Exception("Already connected, use .disconnect() first")
-        await self.realtime.connect()
+        
+        # Use provided model or default
+        if model is None:
+            model = 'gpt-4o-mini-realtime-preview-2024-12-17'
+            
+        await self.realtime.connect(model)
         await self.update_session()
         return True
 
@@ -516,6 +579,7 @@ class RealtimeClient(RealtimeEventHandler):
         self.conversation.clear()
         if self.realtime.is_connected():
             await self.realtime.disconnect()
+        logger.info("RealtimeClient disconnected")
 
     def get_turn_detection_type(self):
         return self.session_config.get("turn_detection", {}).get("type")
@@ -579,11 +643,22 @@ class RealtimeClient(RealtimeEventHandler):
         return True
 
     async def append_input_audio(self, array_buffer):
+        if not self.is_connected():
+            logger.warning("Cannot append audio: RealtimeClient is not connected")
+            return False
+            
         if len(array_buffer) > 0:
-            await self.realtime.send("input_audio_buffer.append", {
-                "audio": array_buffer_to_base64(np.array(array_buffer)),
-            })
-            self.input_audio_buffer.extend(array_buffer)
+            try:
+                await self.realtime.send("input_audio_buffer.append", {
+                    "audio": array_buffer_to_base64(np.array(array_buffer)),
+                })
+                self.input_audio_buffer.extend(array_buffer)
+            except Exception as e:
+                logger.error(f"Failed to append input audio: {e}")
+                # Connection might be lost, mark as disconnected
+                if "connection" in str(e).lower() or "closed" in str(e).lower():
+                    logger.warning("WebSocket connection appears to be lost. Audio input will be queued until reconnection.")
+                return False
         return True
 
     async def create_response(self):
@@ -650,4 +725,17 @@ class RealtimeClient(RealtimeEventHandler):
             logger.debug(f"Unhandled item type:\n{json.dumps(item, indent=2)}")
         
         # Additional debug logging
-        logger.debug(f"Processed Chainlit message for item: {item.get('id', 'unknown')}")
+        logger.debug(f"Processed Chainlit message for item: {item.get('id', 'unknown')}")
+
+    async def ensure_connected(self):
+        """Check connection health and attempt reconnection if needed"""
+        if not self.is_connected():
+            try:
+                logger.info("Attempting to reconnect to OpenAI Realtime API...")
+                model = 'gpt-4o-mini-realtime-preview-2024-12-17'
+                await self.connect(model)
+                return True
+            except Exception as e:
+                logger.error(f"Failed to reconnect: {e}")
+                return False
+        return True

src/praisonai/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.24"
+version = "2.2.25"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.95",
+    "praisonaiagents>=0.0.96",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -95,7 +95,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.24"
+version = "2.2.25"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -113,7 +113,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.95"
+praisonaiagents = ">=0.0.96"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

src/praisonai/tests/unit/test_approval_agent_integration.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""
+Agent Integration Test for Human Approval System
+
+This test demonstrates the approval system working through the agent's execute_tool method,
+which is where the approval checks are actually implemented.
+"""
+
+import sys
+import os
+import asyncio
+import pytest
+
+# Add the praisonai-agents module to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai-agents'))
+
+# Run interactively only when ASK_USER=1 is set
+@pytest.mark.skipif(os.getenv("ASK_USER") != "1", reason="interactive approval requires user input")
+def test_agent_tool_execution_with_approval():
+    """Test that agent tool execution triggers approval prompts."""
+    print("\n🤖 Testing Agent Tool Execution with Approval")
+    print("=" * 50)
+    
+    try:
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, console_approval_callback, ApprovalDecision
+        
+        # Use auto-approval when running non-interactive
+        if os.getenv("ASK_USER") == "1":
+            set_approval_callback(console_approval_callback)
+        else:
+            # Auto-approve for CI
+            def auto_approve_callback(function_name, arguments, risk_level):
+                return ApprovalDecision(approved=True, reason="Auto-approved for CI")
+            set_approval_callback(auto_approve_callback)
+        
+        # Create agent with dangerous tools
+        agent = Agent(
+            name="Test Agent",
+            role="Security Tester",
+            goal="Test the human approval system",
+            tools=[ShellTools()],
+            verbose=True
+        )
+        
+        print("About to execute a shell command through the agent...")
+        print("This should trigger an approval prompt.")
+        
+        # Execute tool through agent - this should trigger approval
+        result = agent.execute_tool("execute_command", {"command": "echo 'Hello from agent-executed command!'"})
+        
+        if result.get('success'):
+            print(f"✅ Command executed successfully: {result['stdout']}")
+        elif result.get('approval_denied'):
+            print(f"❌ Command was denied by approval system: {result['error']}")
+        else:
+            print(f"⚠️ Command failed for other reasons: {result}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Agent tool execution test failed: {e}")
+        return False
+
+def test_agent_with_auto_approval():
+    """Test agent tool execution with auto-approval callback."""
+    print("\n🤖 Testing Agent with Auto-Approval")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Create auto-approval callback
+        def auto_approve_callback(function_name, arguments, risk_level):
+            print(f"🤖 Auto-approving {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=True, reason="Auto-approved for testing")
+        
+        set_approval_callback(auto_approve_callback)
+        
+        # Create agent
+        agent = Agent(
+            name="Auto-Approve Agent",
+            role="Automated Tester",
+            goal="Test auto-approval",
+            tools=[ShellTools()],
+            verbose=False
+        )
+        
+        print("Executing command with auto-approval...")
+        result = agent.execute_tool("execute_command", {"command": "echo 'Auto-approved command executed!'"})
+        
+        if result.get('success'):
+            print(f"✅ Auto-approved command executed: {result['stdout']}")
+        else:
+            print(f"❌ Auto-approved command failed: {result}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Auto-approval test failed: {e}")
+        return False
+
+def test_agent_with_auto_denial():
+    """Test agent tool execution with auto-denial callback."""
+    print("\n🚫 Testing Agent with Auto-Denial")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Create auto-denial callback
+        def auto_deny_callback(function_name, arguments, risk_level):
+            print(f"🚫 Auto-denying {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=False, reason="Auto-denied for testing")
+        
+        set_approval_callback(auto_deny_callback)
+        
+        # Create agent
+        agent = Agent(
+            name="Auto-Deny Agent",
+            role="Security Tester",
+            goal="Test auto-denial",
+            tools=[ShellTools()],
+            verbose=False
+        )
+        
+        print("Executing command with auto-denial...")
+        result = agent.execute_tool("execute_command", {"command": "echo 'This should be denied'"})
+        
+        if result.get('approval_denied'):
+            print("✅ Command was correctly denied by approval system")
+        elif result.get('success'):
+            print("❌ Command executed when it should have been denied")
+        else:
+            print(f"⚠️ Command failed for other reasons: {result}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Auto-denial test failed: {e}")
+        return False
+
+def test_agent_python_code_execution():
+    """Test Python code execution through agent with approval."""
+    print("\n🐍 Testing Agent Python Code Execution")
+    print("=" * 45)
+    
+    try:
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.python_tools import PythonTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Create auto-approval for this test
+        def auto_approve_callback(function_name, arguments, risk_level):
+            print(f"🤖 Auto-approving {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=True, reason="Auto-approved for testing")
+        
+        set_approval_callback(auto_approve_callback)
+        
+        # Create agent
+        agent = Agent(
+            name="Python Agent",
+            role="Code Executor",
+            goal="Test Python code execution",
+            tools=[PythonTools()],
+            verbose=False
+        )
+        
+        code = """
+print("Hello from agent-executed Python code!")
+result = 3 * 7
+print(f"3 * 7 = {result}")
+"""
+        
+        print("Executing Python code through agent...")
+        result = agent.execute_tool("execute_code", {"code": code})
+        
+        if result.get('success'):
+            print(f"✅ Python code executed successfully: {result['output']}")
+        else:
+            print(f"❌ Python code execution failed: {result}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Python code execution test failed: {e}")
+        return False
+
+def test_agent_file_operations():
+    """Test file operations through agent with approval."""
+    print("\n📁 Testing Agent File Operations")
+    print("=" * 35)
+    
+    try:
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.file_tools import FileTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Create auto-approval for this test
+        def auto_approve_callback(function_name, arguments, risk_level):
+            print(f"🤖 Auto-approving {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=True, reason="Auto-approved for testing")
+        
+        set_approval_callback(auto_approve_callback)
+        
+        # Create agent
+        agent = Agent(
+            name="File Agent",
+            role="File Manager",
+            goal="Test file operations",
+            tools=[FileTools()],
+            verbose=False
+        )
+        
+        # Test file creation
+        print("Creating file through agent...")
+        result = agent.execute_tool("write_file", {
+            "file_path": "test_agent_file.txt",
+            "content": "This file was created through agent with approval!"
+        })
+        
+        if result.get('success'):
+            print(f"✅ File created successfully: {result['message']}")
+            
+            # Test file deletion
+            print("Deleting file through agent...")
+            delete_result = agent.execute_tool("delete_file", {"file_path": "test_agent_file.txt"})
+            
+            if delete_result.get('success'):
+                print(f"✅ File deleted successfully: {delete_result['message']}")
+            else:
+                print(f"❌ File deletion failed: {delete_result}")
+        else:
+            print(f"❌ File creation failed: {result}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ File operations test failed: {e}")
+        return False
+
+def main():
+    """Run agent integration tests for the approval system."""
+    print("🧪 PraisonAI Human Approval System - Agent Integration Tests")
+    print("=" * 65)
+    print("These tests demonstrate the approval system working through agent tool execution.")
+    print()
+    
+    # Ask user which tests to run
+    print("Available tests:")
+    print("1. Agent Tool Execution with Interactive Approval")
+    print("2. Agent with Auto-Approval")
+    print("3. Agent with Auto-Denial")
+    print("4. Agent Python Code Execution")
+    print("5. Agent File Operations")
+    print("6. Run all tests")
+    print()
+    
+    try:
+        choice = input("Enter your choice (1-6): ").strip()
+        
+        if choice == "1":
+            test_agent_tool_execution_with_approval()
+        elif choice == "2":
+            test_agent_with_auto_approval()
+        elif choice == "3":
+            test_agent_with_auto_denial()
+        elif choice == "4":
+            test_agent_python_code_execution()
+        elif choice == "5":
+            test_agent_file_operations()
+        elif choice == "6":
+            print("\n🚀 Running all tests...")
+            
+            # Run non-interactive tests first
+            print("\n" + "=" * 65)
+            print("PART 1: NON-INTERACTIVE TESTS")
+            print("=" * 65)
+            test_agent_with_auto_approval()
+            test_agent_with_auto_denial()
+            test_agent_python_code_execution()
+            test_agent_file_operations()
+            
+            # Ask if user wants to run interactive test
+            print("\n" + "=" * 65)
+            print("PART 2: INTERACTIVE TEST")
+            print("=" * 65)
+            print("The following test requires human interaction.")
+            run_interactive = input("Run interactive approval test? (y/n): ").strip().lower()
+            
+            if run_interactive.startswith('y'):
+                test_agent_tool_execution_with_approval()
+            else:
+                print("Skipping interactive test.")
+        else:
+            print("Invalid choice. Exiting.")
+            return
+            
+        print("\n🎉 Test completed!")
+        print("\nKey observations:")
+        print("- Approval system works when tools are executed through agent.execute_tool()")
+        print("- Direct tool calls bypass the approval system")
+        print("- Risk levels are correctly identified and displayed")
+        print("- Auto-approval and auto-denial callbacks work as expected")
+        print("- The approval system integrates properly with the agent architecture")
+        
+    except KeyboardInterrupt:
+        print("\n\n❌ Test cancelled by user.")
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+
+if __name__ == "__main__":
+    main() 

src/praisonai/tests/unit/test_approval_basic.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+Basic test to verify the human approval system implementation.
+
+This test focuses on ensuring the approval decorators and callback system work correctly.
+"""
+
+import sys
+import os
+import asyncio
+
+# Add the praisonai-agents module to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai-agents'))
+
+def test_imports():
+    """Test that all the new approval imports work correctly."""
+    try:
+        from praisonaiagents.approval import (
+            require_approval,
+            ApprovalDecision,
+            console_approval_callback,
+            request_approval,
+            add_approval_requirement,
+            remove_approval_requirement,
+            is_approval_required,
+            get_risk_level,
+            APPROVAL_REQUIRED_TOOLS,
+            TOOL_RISK_LEVELS
+        )
+        print("✅ All approval imports successful")
+        return True
+    except ImportError as e:
+        print(f"❌ Import failed: {e}")
+        return False
+
+def test_approval_configuration():
+    """Test approval requirement configuration."""
+    from praisonaiagents.approval import (
+        add_approval_requirement, 
+        remove_approval_requirement, 
+        is_approval_required, 
+        get_risk_level,
+        APPROVAL_REQUIRED_TOOLS,
+        TOOL_RISK_LEVELS
+    )
+    
+    print("\n🔧 Testing approval configuration...")
+    
+    # Test adding requirement
+    add_approval_requirement("test_tool", "medium")
+    assert is_approval_required("test_tool"), "Tool should require approval after adding"
+    assert get_risk_level("test_tool") == "medium", "Risk level should be medium"
+    print("✅ Add approval requirement works")
+    
+    # Test removing requirement
+    remove_approval_requirement("test_tool")
+    assert not is_approval_required("test_tool"), "Tool should not require approval after removing"
+    assert get_risk_level("test_tool") is None, "Risk level should be None after removal"
+    print("✅ Remove approval requirement works")
+    
+    # Test default dangerous tools are configured
+    assert is_approval_required("execute_command"), "execute_command should require approval by default"
+    assert get_risk_level("execute_command") == "critical", "execute_command should be critical risk"
+    print("✅ Default dangerous tools are configured")
+    
+    print(f"✅ Current approval-required tools: {len(APPROVAL_REQUIRED_TOOLS)} configured")
+    return True
+
+def test_approval_decorator():
+    """Test the require_approval decorator."""
+    from praisonaiagents.approval import require_approval, is_approval_required, get_risk_level
+    
+    print("\n🎯 Testing approval decorator...")
+    
+    # Test decorator on a test function
+    @require_approval(risk_level="high")
+    def test_dangerous_function(param1, param2="default"):
+        """A test function that requires approval."""
+        return f"Executed with {param1} and {param2}"
+    
+    # Check if the function is marked as requiring approval
+    assert is_approval_required("test_dangerous_function"), "Decorated function should require approval"
+    assert get_risk_level("test_dangerous_function") == "high", "Risk level should match decorator"
+    print("✅ Approval decorator works correctly")
+    
+    # Test that the function still executes normally (approval will be checked at agent level)
+    result = test_dangerous_function("test", param2="value")
+    assert "Executed with test and value" in result, "Function should execute normally"
+    print("✅ Decorated function executes correctly")
+    
+    return True
+
+def test_tool_integration():
+    """Test that dangerous tools have approval decorators."""
+    print("\n🛠️ Testing tool integration...")
+    
+    # Test shell tools
+    try:
+        from praisonaiagents.tools.shell_tools import ShellTools
+        shell_tools = ShellTools()
+        
+        # Check if execute_command requires approval
+        from praisonaiagents.approval import is_approval_required
+        assert is_approval_required("execute_command"), "execute_command should require approval"
+        print("✅ ShellTools.execute_command requires approval")
+        
+        # Check if kill_process requires approval
+        assert is_approval_required("kill_process"), "kill_process should require approval"
+        print("✅ ShellTools.kill_process requires approval")
+        
+    except Exception as e:
+        print(f"⚠️ Shell tools test failed: {e}")
+        
+    # Test python tools
+    try:
+        from praisonaiagents.tools.python_tools import PythonTools
+        python_tools = PythonTools()
+        
+        # Check if execute_code requires approval
+        assert is_approval_required("execute_code"), "execute_code should require approval"
+        print("✅ PythonTools.execute_code requires approval")
+        
+    except Exception as e:
+        print(f"⚠️ Python tools test failed: {e}")
+        
+    # Test file tools
+    try:
+        from praisonaiagents.tools.file_tools import FileTools
+        file_tools = FileTools()
+        
+        # Check if write_file requires approval
+        assert is_approval_required("write_file"), "write_file should require approval"
+        print("✅ FileTools.write_file requires approval")
+        
+        # Check if delete_file requires approval
+        assert is_approval_required("delete_file"), "delete_file should require approval"
+        print("✅ FileTools.delete_file requires approval")
+        
+    except Exception as e:
+        print(f"⚠️ File tools test failed: {e}")
+    
+    return True
+
+async def test_approval_callback():
+    """Test the approval callback system."""
+    print("\n📞 Testing approval callback system...")
+    
+    from praisonaiagents.approval import request_approval, ApprovalDecision
+    
+    # Mock approval that auto-denies
+    def mock_denial_callback(function_name, arguments, risk_level):
+        print(f"🔒 Mock callback: Denying {function_name} (risk: {risk_level})")
+        return ApprovalDecision(approved=False, reason="Test denial")
+    
+    # Mock approval that auto-approves
+    def mock_approval_callback(function_name, arguments, risk_level):
+        print(f"✅ Mock callback: Approving {function_name} (risk: {risk_level})")
+        return ApprovalDecision(approved=True, reason="Test approval")
+    
+    # Test with denial callback
+    from praisonaiagents.approval import set_approval_callback
+    set_approval_callback(mock_denial_callback)
+    
+    decision = await request_approval("execute_command", {"command": "ls"})
+    assert not decision.approved, "Should be denied by mock callback"
+    assert "Test denial" in decision.reason, "Should have denial reason"
+    print("✅ Denial callback works")
+    
+    # Test with approval callback  
+    set_approval_callback(mock_approval_callback)
+    
+    decision = await request_approval("execute_command", {"command": "ls"})
+    assert decision.approved, "Should be approved by mock callback"
+    assert "Test approval" in decision.reason, "Should have approval reason"
+    print("✅ Approval callback works")
+    
+    # Test non-dangerous tool (should auto-approve)
+    decision = await request_approval("safe_function", {})
+    assert decision.approved, "Non-dangerous tools should auto-approve"
+    assert "No approval required" in decision.reason, "Should indicate no approval needed"
+    print("✅ Non-dangerous tools auto-approve")
+    
+    return True
+
+def test_agent_integration():
+    """Test that agents properly integrate with the approval system."""
+    print("\n🤖 Testing agent integration...")
+    
+    try:
+        from praisonaiagents import Agent
+        from praisonaiagents.tools.shell_tools import ShellTools
+        
+        # Create agent with dangerous tools
+        agent = Agent(
+            name="Test Agent",
+            role="Tester",
+            goal="Test approval integration",
+            tools=[ShellTools()],
+            verbose=False
+        )
+        
+        print("✅ Agent created with dangerous tools")
+        
+        # Check that agent has the approval callback configured
+        from praisonaiagents.main import approval_callback
+        print(f"✅ Global approval callback configured: {approval_callback is not None}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"⚠️ Agent integration test failed: {e}")
+        return False
+
+def main():
+    """Run all approval system tests."""
+    print("🧪 PraisonAI Human Approval System Test Suite")
+    print("=" * 50)
+    
+    test_results = []
+    
+    # Run synchronous tests
+    test_results.append(("Imports", test_imports()))
+    test_results.append(("Configuration", test_approval_configuration()))
+    test_results.append(("Decorator", test_approval_decorator()))
+    test_results.append(("Tool Integration", test_tool_integration()))
+    test_results.append(("Agent Integration", test_agent_integration()))
+    
+    # Run async tests
+    try:
+        async_result = asyncio.run(test_approval_callback())
+        test_results.append(("Approval Callback", async_result))
+    except Exception as e:
+        print(f"❌ Async test failed: {e}")
+        test_results.append(("Approval Callback", False))
+    
+    # Print summary
+    print("\n" + "=" * 50)
+    print("📊 TEST SUMMARY")
+    print("=" * 50)
+    
+    passed = 0
+    failed = 0
+    
+    for test_name, result in test_results:
+        status = "✅ PASSED" if result else "❌ FAILED"
+        print(f"{test_name:<20} {status}")
+        if result:
+            passed += 1
+        else:
+            failed += 1
+    
+    print(f"\nTotal: {passed + failed} tests")
+    print(f"Passed: {passed}")
+    print(f"Failed: {failed}")
+    
+    if failed == 0:
+        print("\n🎉 All tests passed! Human approval system is working correctly.")
+        return True
+    else:
+        print(f"\n❌ {failed} test(s) failed. Please check the implementation.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

src/praisonai/tests/unit/test_approval_interactive.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""
+Interactive test for the human approval system.
+
+This test actually calls dangerous tools to trigger approval prompts,
+allowing you to test the human-in-the-loop functionality.
+"""
+
+import sys
+import os
+import asyncio
+import pytest
+
+# Add the praisonai-agents module to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', '..', 'praisonai-agents'))
+
+@pytest.mark.skipif(os.getenv("ASK_USER") != "1", reason="interactive approval requires user input")
+def test_shell_command_approval():
+    """Test shell command execution with approval prompts."""
+    print("\n🐚 Testing Shell Command Approval")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, console_approval_callback, ApprovalDecision
+        
+        # Use auto-approval when running non-interactive
+        if os.getenv("ASK_USER") == "1":
+            set_approval_callback(console_approval_callback)
+        else:
+            # Auto-approve for CI
+            def auto_approve_callback(function_name, arguments, risk_level):
+                return ApprovalDecision(approved=True, reason="Auto-approved for CI")
+            set_approval_callback(auto_approve_callback)
+        
+        shell_tools = ShellTools()
+        
+        print("About to execute a shell command that requires approval...")
+        print("You should see an approval prompt.")
+        
+        # This should trigger an approval prompt
+        result = shell_tools.execute_command("echo 'Hello from approved shell command!'")
+        
+        if result.get('success'):
+            print(f"✅ Command executed successfully: {result['stdout']}")
+        else:
+            print(f"❌ Command failed or was denied: {result.get('stderr', 'Unknown error')}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Shell command test failed: {e}")
+        return False
+
+@pytest.mark.skipif(os.getenv("ASK_USER") != "1", reason="interactive approval requires user input")
+def test_python_code_approval():
+    """Test Python code execution with approval prompts."""
+    print("\n🐍 Testing Python Code Approval")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents.tools.python_tools import PythonTools
+        from praisonaiagents.approval import set_approval_callback, console_approval_callback, ApprovalDecision
+        
+        # Use auto-approval when running non-interactive
+        if os.getenv("ASK_USER") == "1":
+            set_approval_callback(console_approval_callback)
+        else:
+            # Auto-approve for CI
+            def auto_approve_callback(function_name, arguments, risk_level):
+                return ApprovalDecision(approved=True, reason="Auto-approved for CI")
+            set_approval_callback(auto_approve_callback)
+        
+        python_tools = PythonTools()
+        
+        print("About to execute Python code that requires approval...")
+        print("You should see an approval prompt.")
+        
+        # This should trigger an approval prompt
+        code = """
+print("Hello from approved Python code!")
+result = 2 + 2
+print(f"2 + 2 = {result}")
+"""
+        
+        result = python_tools.execute_code(code)
+        
+        if result.get('success'):
+            print(f"✅ Code executed successfully: {result['output']}")
+        else:
+            print(f"❌ Code failed or was denied: {result.get('error', 'Unknown error')}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Python code test failed: {e}")
+        return False
+
+@pytest.mark.skipif(os.getenv("ASK_USER") != "1", reason="interactive approval requires user input")
+def test_file_operation_approval():
+    """Test file operations with approval prompts."""
+    print("\n📁 Testing File Operation Approval")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents.tools.file_tools import FileTools
+        from praisonaiagents.approval import set_approval_callback, console_approval_callback, ApprovalDecision
+        
+        # Use auto-approval when running non-interactive
+        if os.getenv("ASK_USER") == "1":
+            set_approval_callback(console_approval_callback)
+        else:
+            # Auto-approve for CI
+            def auto_approve_callback(function_name, arguments, risk_level):
+                return ApprovalDecision(approved=True, reason="Auto-approved for CI")
+            set_approval_callback(auto_approve_callback)
+        
+        file_tools = FileTools()
+        
+        print("About to create a file that requires approval...")
+        print("You should see an approval prompt.")
+        
+        # This should trigger an approval prompt
+        result = file_tools.write_file(
+            file_path="test_approval_file.txt",
+            content="This file was created with human approval!"
+        )
+        
+        if result.get('success'):
+            print(f"✅ File created successfully: {result['message']}")
+            
+            # Now test deletion (also requires approval)
+            print("\nAbout to delete the file (also requires approval)...")
+            delete_result = file_tools.delete_file("test_approval_file.txt")
+            
+            if delete_result.get('success'):
+                print(f"✅ File deleted successfully: {delete_result['message']}")
+            else:
+                print(f"❌ File deletion failed or was denied: {delete_result.get('error', 'Unknown error')}")
+        else:
+            print(f"❌ File creation failed or was denied: {result.get('error', 'Unknown error')}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ File operation test failed: {e}")
+        return False
+
+def test_auto_approval_callback():
+    """Test with an auto-approval callback for non-interactive testing."""
+    print("\n🤖 Testing Auto-Approval Callback")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Create an auto-approval callback
+        def auto_approve_callback(function_name, arguments, risk_level):
+            print(f"🤖 Auto-approving {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=True, reason="Auto-approved for testing")
+        
+        set_approval_callback(auto_approve_callback)
+        
+        shell_tools = ShellTools()
+        
+        print("Executing command with auto-approval...")
+        result = shell_tools.execute_command("echo 'Auto-approved command executed!'")
+        
+        if result.get('success'):
+            print(f"✅ Auto-approved command executed: {result['stdout']}")
+        else:
+            print(f"❌ Auto-approved command failed: {result.get('stderr', 'Unknown error')}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Auto-approval test failed: {e}")
+        return False
+
+def test_auto_denial_callback():
+    """Test with an auto-denial callback."""
+    print("\n🚫 Testing Auto-Denial Callback")
+    print("=" * 40)
+    
+    try:
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Create an auto-denial callback
+        def auto_deny_callback(function_name, arguments, risk_level):
+            print(f"🚫 Auto-denying {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=False, reason="Auto-denied for testing")
+        
+        set_approval_callback(auto_deny_callback)
+        
+        shell_tools = ShellTools()
+        
+        print("Executing command with auto-denial...")
+        result = shell_tools.execute_command("echo 'This should be denied'")
+        
+        if result.get('approval_denied'):
+            print("✅ Command was correctly denied by approval system")
+        elif result.get('success'):
+            print("❌ Command executed when it should have been denied")
+        else:
+            print(f"⚠️ Command failed for other reasons: {result}")
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Auto-denial test failed: {e}")
+        return False
+
+def main():
+    """Run interactive approval tests."""
+    print("🧪 PraisonAI Human Approval System - Interactive Tests")
+    print("=" * 60)
+    print("This test will demonstrate the human approval system in action.")
+    print("You will be prompted to approve or deny dangerous operations.")
+    print()
+    
+    # Ask user which tests to run
+    print("Available tests:")
+    print("1. Shell Command Approval (interactive)")
+    print("2. Python Code Approval (interactive)")
+    print("3. File Operation Approval (interactive)")
+    print("4. Auto-Approval Test (non-interactive)")
+    print("5. Auto-Denial Test (non-interactive)")
+    print("6. Run all tests")
+    print()
+    
+    try:
+        choice = input("Enter your choice (1-6): ").strip()
+        
+        if choice == "1":
+            test_shell_command_approval()
+        elif choice == "2":
+            test_python_code_approval()
+        elif choice == "3":
+            test_file_operation_approval()
+        elif choice == "4":
+            test_auto_approval_callback()
+        elif choice == "5":
+            test_auto_denial_callback()
+        elif choice == "6":
+            print("\n🚀 Running all tests...")
+            
+            # Run non-interactive tests first
+            print("\n" + "=" * 60)
+            print("PART 1: NON-INTERACTIVE TESTS")
+            print("=" * 60)
+            test_auto_approval_callback()
+            test_auto_denial_callback()
+            
+            # Ask if user wants to run interactive tests
+            print("\n" + "=" * 60)
+            print("PART 2: INTERACTIVE TESTS")
+            print("=" * 60)
+            print("The following tests require human interaction.")
+            run_interactive = input("Run interactive tests? (y/n): ").strip().lower()
+            
+            if run_interactive.startswith('y'):
+                test_shell_command_approval()
+                test_python_code_approval()
+                test_file_operation_approval()
+            else:
+                print("Skipping interactive tests.")
+        else:
+            print("Invalid choice. Exiting.")
+            return
+            
+        print("\n🎉 Test completed!")
+        print("\nKey observations:")
+        print("- Dangerous operations should trigger approval prompts")
+        print("- Risk levels should be displayed correctly")
+        print("- Approved operations should execute normally")
+        print("- Denied operations should be blocked")
+        print("- Auto-approval/denial callbacks should work as expected")
+        
+    except KeyboardInterrupt:
+        print("\n\n❌ Test cancelled by user.")
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+
+if __name__ == "__main__":
+    main() 

src/praisonai/tests/unit/test_decorator_enforcement.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Test script to verify that the require_approval decorator now enforces approval
+even when tools are called directly (not through agent.execute_tool).
+"""
+
+import sys
+import os
+
+# Add the praisonai-agents module to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src', 'praisonai-agents'))
+
+def test_decorator_enforcement():
+    """Test that the decorator actually enforces approval."""
+    print("🧪 Testing Decorator Enforcement")
+    print("=" * 35)
+    
+    try:
+        from praisonaiagents.tools.shell_tools import ShellTools
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        # Set auto-denial to test enforcement
+        def auto_deny(function_name, arguments, risk_level):
+            print(f"🚫 Denying {function_name} (risk: {risk_level})")
+            return ApprovalDecision(approved=False, reason='Test denial')
+        
+        set_approval_callback(auto_deny)
+        
+        shell_tools = ShellTools()
+        
+        print("Attempting to execute command directly (should be blocked)...")
+        
+        try:
+            # This should now be blocked by the decorator
+            result = shell_tools.execute_command('echo "This should be denied"')
+            print('❌ Command executed when it should have been denied!')
+            return False
+        except PermissionError as e:
+            print(f'✅ Decorator enforcement working: {e}')
+            return True
+        except Exception as e:
+            print(f'❌ Unexpected error: {e}')
+            return False
+            
+    except Exception as e:
+        print(f"❌ Test setup failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = test_decorator_enforcement()
+    if success:
+        print("\n🎉 Decorator enforcement is working correctly!")
+    else:
+        print("\n❌ Decorator enforcement test failed!")
+    sys.exit(0 if success else 1) 

src/praisonai/tests/unit/test_decorator_simple.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Simple test to verify the improved require_approval decorator.
+"""
+
+import sys
+import os
+
+# Add the praisonai-agents module to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src', 'praisonai-agents'))
+
+def test_improved_decorator():
+    """Test the improved decorator with context management."""
+    print("🧪 Testing Improved Decorator with Context Management")
+    print("=" * 55)
+    
+    try:
+        from praisonaiagents.approval import (
+            require_approval, set_approval_callback, ApprovalDecision,
+            mark_approved, is_already_approved, clear_approval_context
+        )
+        
+        # Clear any previous context
+        clear_approval_context()
+        
+        # Create a test function
+        @require_approval(risk_level="critical")
+        def test_function(message="test"):
+            return f"Function executed: {message}"
+        
+        print("✅ Test function decorated successfully")
+        
+        # Test 1: Direct call without approval (should fail)
+        print("\n1. Testing direct call without approval (should fail)...")
+        
+        def auto_deny(function_name, arguments, risk_level):
+            return ApprovalDecision(approved=False, reason='Test denial')
+        
+        set_approval_callback(auto_deny)
+        
+        try:
+            result = test_function("direct call")
+            print(f"❌ Function executed when it should have been denied: {result}")
+        except PermissionError as e:
+            print(f"✅ Correctly denied: {e}")
+        
+        # Test 2: Mark as approved and call (should succeed)
+        print("\n2. Testing with approval context (should succeed)...")
+        
+        mark_approved("test_function")
+        
+        try:
+            result = test_function("approved context")
+            print(f"✅ Function executed with approved context: {result}")
+        except Exception as e:
+            print(f"❌ Function failed in approved context: {e}")
+        
+        # Test 3: Clear context and test auto-approval
+        print("\n3. Testing auto-approval callback...")
+        
+        clear_approval_context()
+        
+        def auto_approve(function_name, arguments, risk_level):
+            return ApprovalDecision(approved=True, reason='Test approval')
+        
+        set_approval_callback(auto_approve)
+        
+        try:
+            result = test_function("auto approved")
+            print(f"✅ Function executed with auto-approval: {result}")
+        except Exception as e:
+            print(f"❌ Function failed with auto-approval: {e}")
+        
+        # Test 4: Verify context is working
+        print("\n4. Testing context persistence...")
+        
+        if is_already_approved("test_function"):
+            print("✅ Context correctly shows function as approved")
+        else:
+            print("❌ Context not working correctly")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = test_improved_decorator()
+    if success:
+        print("\n🎉 Improved decorator approach is working correctly!")
+        print("\nKey improvements:")
+        print("- ✅ Context management prevents double approval")
+        print("- ✅ Proper async handling")
+        print("- ✅ Decorator actually enforces approval")
+        print("- ✅ Agent integration marks tools as approved")
+    else:
+        print("\n❌ Improved decorator test failed!")
+    
+    sys.exit(0 if success else 1) 

src/praisonai/tests/unit/test_graph_memory.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+Quick test script to verify graph memory implementation
+"""
+
+import sys
+import os
+
+# Add the source directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src', 'praisonai-agents'))
+
+def test_memory_import():
+    """Test that Memory class can be imported and initialized"""
+    try:
+        from praisonaiagents.memory import Memory
+        print("✅ Memory class imported successfully")
+        return True
+    except ImportError as e:
+        print(f"❌ Failed to import Memory: {e}")
+        return False
+
+def test_knowledge_import():
+    """Test that Knowledge class can be imported"""
+    try:
+        from praisonaiagents.knowledge import Knowledge
+        print("✅ Knowledge class imported successfully")
+        return True
+    except ImportError as e:
+        print(f"❌ Failed to import Knowledge: {e}")
+        return False
+
+def test_memory_config():
+    """Test memory configuration with graph support"""
+    try:
+        from praisonaiagents.memory import Memory
+        
+        # Test basic configuration
+        basic_config = {
+            "provider": "mem0",
+            "config": {
+                "vector_store": {
+                    "provider": "chroma",
+                    "config": {"path": ".test_memory"}
+                }
+            }
+        }
+        
+        memory = Memory(config=basic_config, verbose=1)
+        print("✅ Basic memory configuration works")
+        
+        # Test graph configuration (will fallback gracefully if dependencies missing)
+        graph_config = {
+            "provider": "mem0",
+            "config": {
+                "graph_store": {
+                    "provider": "memgraph",
+                    "config": {
+                        "url": "bolt://localhost:7687",
+                        "username": "memgraph",
+                        "password": ""
+                    }
+                }
+            }
+        }
+        
+        try:
+            memory_graph = Memory(config=graph_config, verbose=1)
+            print("✅ Graph memory configuration initialized")
+            print(f"   Graph enabled: {getattr(memory_graph, 'graph_enabled', False)}")
+        except Exception as e:
+            print(f"⚠️  Graph memory not available (expected): {e}")
+            print("   This is normal if graph dependencies are not installed")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Memory configuration test failed: {e}")
+        return False
+
+def test_knowledge_config():
+    """Test knowledge configuration with graph support"""
+    try:
+        from praisonaiagents.knowledge import Knowledge
+        
+        # Test basic knowledge config
+        basic_config = {
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": "test_collection",
+                    "path": ".test_knowledge"
+                }
+            }
+        }
+        
+        knowledge = Knowledge(config=basic_config, verbose=0)
+        print("✅ Basic knowledge configuration works")
+        
+        # Test knowledge with graph config
+        graph_config = {
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": "test_graph_collection",
+                    "path": ".test_graph_knowledge"
+                }
+            },
+            "graph_store": {
+                "provider": "memgraph",
+                "config": {
+                    "url": "bolt://localhost:7687",
+                    "username": "memgraph",
+                    "password": ""
+                }
+            }
+        }
+        
+        knowledge_graph = Knowledge(config=graph_config, verbose=0)
+        print("✅ Graph knowledge configuration created")
+        
+        # Check if config contains graph_store
+        final_config = knowledge_graph.config
+        if "graph_store" in final_config:
+            print("✅ Graph store configuration preserved in knowledge config")
+        else:
+            print("❌ Graph store configuration not found in knowledge config")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Knowledge configuration test failed: {e}")
+        return False
+
+def main():
+    print("🧪 Testing Graph Memory Implementation")
+    print("=" * 50)
+    
+    tests = [
+        ("Memory Import", test_memory_import),
+        ("Knowledge Import", test_knowledge_import), 
+        ("Memory Configuration", test_memory_config),
+        ("Knowledge Configuration", test_knowledge_config)
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        print(f"\n🔬 Testing {test_name}...")
+        try:
+            if test_func():
+                passed += 1
+        except Exception as e:
+            print(f"❌ Test {test_name} crashed: {e}")
+    
+    print(f"\n📊 Test Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! Graph memory implementation is working correctly.")
+    else:
+        print("⚠️  Some tests failed. This might be expected if dependencies are missing.")
+    
+    print("\n💡 To fully test graph memory, install dependencies:")
+    print("   pip install \"mem0ai[graph]\"")
+    print("   docker run -p 7687:7687 memgraph/memgraph-mage:latest")
+
+if __name__ == "__main__":
+    main()

src/praisonai/uv.lock

@@ -3931,7 +3931,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.2.24"
+version = "2.2.25"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -4073,7 +4073,7 @@ requires-dist = [
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.15" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.15" },
-    { name = "praisonaiagents", specifier = ">=0.0.95" },
+    { name = "praisonaiagents", specifier = ">=0.0.96" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4130,7 +4130,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.95"
+version = "0.0.96"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mcp" },
@@ -4138,9 +4138,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6a/7c/c6ae58b98d652f3c986683e72883eda5a3a4c2de054c01f6674ebdb0ae26/praisonaiagents-0.0.95.tar.gz", hash = "sha256:3b71869c3c73241e7dee109232d492545ea2a397fbfd9c922d4c9cfd41d93094", size = 127328 }
+sdist = { url = "https://files.pythonhosted.org/packages/10/53/2e1facaed976a6c428b67756108d2370b5ca9249356c7c71b7d6e1a28421/praisonaiagents-0.0.96.tar.gz", hash = "sha256:96ff46fbdb54162cf721c94fb04e95eae3f0d9305fd1939bad31fa1aca7b4231", size = 127366 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/d2/63c8725b03d4f4bb1387594ed2cf93d1d544a6216ec7c374536ebfe6bf2a/praisonaiagents-0.0.95-py3-none-any.whl", hash = "sha256:04528314fd23240b4cb388149d8f181714753e6a3b68d429de46f66fc2c94857", size = 145811 },
+    { url = "https://files.pythonhosted.org/packages/4c/d1/89935abb42bd1c1cda1981583e4b6a2058b5c79e157a062489f581dba9b2/praisonaiagents-0.0.96-py3-none-any.whl", hash = "sha256:6d70884a7033e124510c13c80eb1e19dbad6c04d58eb8f0cfceb30fb9c91f85f", size = 145812 },
 ]
 
 [[package]]