Merge pull request #292 from MervinPraison/develop

Update PraisonAI and praisonaiagents to version 2.0.45 and 0.0.35 res…

.env.example

@@ -0,0 +1,6 @@
+OPENAI_MODEL_NAME="gpt-4o"
+OPENAI_API_KEY="Enter your API key"
+OPENAI_API_BASE="https://api.openai.com/v1"
+CHAINLIT_USERNAME=admin
+CHAINLIT_USERNAME=admin
+CHAINLIT_AUTH_SECRET="chainlit create-secret to create"

.eslintrc

@@ -0,0 +1,10 @@
+{
+    "extends": ["plugin:mdx/recommended"],
+    // optional, if you want to lint code blocks at the same time
+    "settings": {
+      "mdx/code-blocks": true,
+      // optional, if you want to disable language mapper, set it to `false`
+      // if you want to override the default language mapper inside, you can provide your own
+      "mdx/language-mapper": {}
+    }
+  }

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+patreon: MervinPraison
+ko_fi: MervinPraison

.github/workflows/docker-publish.yml

@@ -0,0 +1,44 @@
+name: Daily Publish Docker
+
+on:
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  check-and-build:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Check last commit time
+        id: check_commit
+        run: |
+          last_commit_time=$(git log -1 --format=%ct)
+          current_time=$(date +%s)
+          time_diff=$((current_time - last_commit_time))
+          if [ $time_diff -ge 120 ] && [ $time_diff -lt 240 ]; then
+            echo "should_run=true" >> $GITHUB_OUTPUT
+          else
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Set up Docker Buildx
+        if: steps.check_commit.outputs.should_run == 'true'
+        uses: docker/setup-buildx-action@v1
+
+      - name: Log in to the GitHub Container Registry
+        if: steps.check_commit.outputs.should_run == 'true'
+        run: echo ${{ secrets.GH_TOKEN }} | docker login ghcr.io -u USERNAME --password-stdin
+
+      - name: Build and push Docker image
+        if: steps.check_commit.outputs.should_run == 'true'
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          tags: ghcr.io/mervinpraison/praisonai:latest

.github/workflows/python-package.yml

@@ -0,0 +1,40 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python package
+
+on:
+  push:
+    branches: [ "develop" ]
+  pull_request:
+    branches: [ "develop" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    # - name: Lint with flake8
+    #   run: |
+    #     # stop the build if there are Python syntax errors or undefined names
+    #     flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+    #     # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+    #     flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    # - name: Test with pytest
+    #   run: |
+    #     pytest

.github/workflows/python-publish.yml

@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/release.yml

@@ -0,0 +1,524 @@
+name: Release Workflow
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Tag to create release with (e.g., v2.0.10)'
+        required: true
+      fork_owner:
+        description: 'GitHub username of the fork owner'
+        required: true
+        default: 'tosin2013'
+
+jobs:
+  test-ubuntu:
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, ubuntu-24.04]
+        framework: ['crewai', 'autogen']
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 90
+
+    steps:
+    # First checkout the upstream repo at the specified tag
+    - name: Checkout upstream repo
+      uses: actions/checkout@v4
+      with:
+        repository: MervinPraison/PraisonAI
+        ref: ${{ github.event.inputs.tag }}
+        fetch-depth: 0
+
+    # Get the commit hash from the tag
+    - name: Get commit hash
+      id: get_commit
+      run: |
+        COMMIT_HASH=$(git rev-parse HEAD)
+        echo "commit_hash=$COMMIT_HASH" >> $GITHUB_OUTPUT
+        echo "Found commit: $COMMIT_HASH for tag ${{ github.event.inputs.tag }}"
+
+    # Now checkout the fork at main branch
+    - name: Checkout fork
+      uses: actions/checkout@v4
+      with:
+        repository: ${{ github.event.inputs.fork_owner }}/PraisonAI
+        ref: main
+        fetch-depth: 0
+        clean: true
+
+    # Sync with upstream commit
+    - name: Sync with upstream
+      run: |
+        git config --global user.name "GitHub Actions"
+        git config --global user.email "[email protected]"
+        
+        # Add upstream remote
+        git remote add upstream https://github.com/MervinPraison/PraisonAI.git
+        
+        # Fetch from upstream
+        git fetch upstream --tags --force
+        
+        # Reset to upstream commit
+        git reset --hard ${{ steps.get_commit.outputs.commit_hash }}
+
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+        cache: 'pip'
+
+    - name: Install Poetry
+      run: |
+        curl -sSL https://install.python-poetry.org | python3 -
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+        poetry config virtualenvs.in-project true
+        poetry config virtualenvs.create true
+        poetry --version
+        poetry config --list
+
+    - name: Install Dependencies
+      run: |
+        poetry lock #--no-update
+        poetry install --all-extras
+        poetry env info
+        # Verify venv exists
+        test -d .venv || { echo "Virtual environment not created!"; exit 1; }
+        test -f .venv/bin/activate || { echo "Activation script not found!"; exit 1; }
+
+    - name: Run setup script
+      timeout-minutes: 20
+      run: |
+        set -e  # Exit on any error
+        curl -OL https://raw.githubusercontent.com/tosin2013/PraisonAI/refs/heads/main/setup.sh
+        chmod +x setup.sh
+        ./setup.sh --all --cicd || { echo "Setup script failed"; exit 1; }
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Test Basic Functionality
+      run: |
+        set -e  # Exit on any error
+        
+        # Random sleep between 60-120 seconds to avoid API rate limits
+        SLEEP_TIME=$((RANDOM % 61 + 60))
+        echo "Sleeping for $SLEEP_TIME seconds to avoid API rate limits..."
+        sleep $SLEEP_TIME
+        
+        lsof -ti:8084 | xargs -r kill -9 || true
+        source .venv/bin/activate || { echo "Failed to activate virtual environment"; exit 1; }
+        mkdir -p test_output || { echo "Failed to create test_output directory"; exit 1; }
+        
+        echo "Testing basic CLI functionality..."
+        
+        # Test auto generation with explicit framework
+        praisonai --framework ${{ matrix.framework }}  --auto "create a short test script" 2>&1 | tee test_output/auto_test.log
+        
+        # Verify the output file exists and has content
+        if [[ ! -s test_output/auto_test.log ]]; then
+          echo "Error: No output generated from auto test"
+          exit 1
+        fi
+        
+        # Test auto generation without framework
+        echo "Basic functionality tests passed!"
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        LOGLEVEL: "debug"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Test Framework-specific Features
+      continue-on-error: false
+      run: |
+        source .venv/bin/activate
+        
+        # Random sleep between 60-120 seconds to avoid API rate limits
+        SLEEP_TIME=$((RANDOM % 61 + 60))
+        echo "Sleeping for $SLEEP_TIME seconds to avoid API rate limits..."
+        sleep $SLEEP_TIME
+        
+        lsof -ti:8084 | xargs -r kill -9 || true
+        praisonai --framework ${{ matrix.framework }} --auto "create a movie script about Robots in Mars" 2>&1 | tee test_output/framework_output.txt || echo "Framework-specific test failed" >> test_output/errors.log
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Test Core Functionality
+      continue-on-error: false
+      run: |
+        source .venv/bin/activate
+        
+        # Random sleep between 60-120 seconds to avoid API rate limits
+        SLEEP_TIME=$((RANDOM % 61 + 60))
+        echo "Sleeping for $SLEEP_TIME seconds to avoid API rate limits..."
+        sleep $SLEEP_TIME
+        
+        echo "Testing core functionality..."
+        
+        # Test package imports
+        python3 -c "from praisonai.cli import PraisonAI; from praisonai.auto import AutoGenerator; from praisonai.agents_generator import AgentsGenerator" || exit 1
+        
+        # Test configuration loading
+        python3 -c "from praisonai.inc.config import generate_config; print(generate_config())" || exit 1
+        
+        # Test tools loading
+        python3 -c "from praisonai.inbuilt_tools import *" || exit 1
+        
+        echo "Core functionality tests passed!"
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        LOGLEVEL: "debug"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Test Agent Generation
+      continue-on-error: false
+      run: |
+        source .venv/bin/activate
+        
+        # Random sleep between 60-120 seconds to avoid API rate limits
+        SLEEP_TIME=$((RANDOM % 61 + 60))
+        echo "Sleeping for $SLEEP_TIME seconds to avoid API rate limits..."
+        sleep $SLEEP_TIME
+        
+        echo "Testing agent generation..."
+        
+        # Create a test YAML file
+        cat > test_agents.yaml <<EOF
+        topic: "Test automation task"
+        framework: "${{ matrix.framework }} "
+        roles:
+          - name: "Tester"
+            goal: "Test the system"
+            backstory: "Expert system tester"
+            tasks:
+              - description: "Verify system functionality"
+                expected_output: "Test results"
+        EOF
+        
+        # Test YAML loading and agent generation
+        python3 -c '
+        from praisonai.agents_generator import AgentsGenerator
+        config = [{"model": "llama-3.3-70b-versatile", "base_url": "https://api.groq.com/openai/v1/"}]
+        generator = AgentsGenerator("test_agents.yaml", "${{ matrix.framework }} ", config)
+        print("Agent generation test passed!")
+        ' || exit 1
+        
+        echo "Agent generation tests passed!"
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        LOGLEVEL: "debug"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Test Custom Tools Integration
+      continue-on-error: false
+      run: |
+        source .venv/bin/activate
+        
+        # Random sleep between 60-120 seconds to avoid API rate limits
+        SLEEP_TIME=$((RANDOM % 61 + 60))
+        echo "Sleeping for $SLEEP_TIME seconds to avoid API rate limits..."
+        sleep $SLEEP_TIME
+        
+        echo "Testing custom tools integration..."
+        
+        # Create a test tool
+        cat > test_tool.py <<EOF
+        from duckduckgo_search import DDGS
+        from praisonai_tools import BaseTool
+
+        class InternetSearchTool(BaseTool):
+            name: str = "Internet Search Tool"
+            description: str = "Search Internet for relevant information"
+
+            def _run(self, query: str):
+                return {"status": "success", "query": query}
+                
+            def test(self):
+                """Test method to verify tool setup"""
+                test_query = "test query"
+                result = self._run(test_query)
+                assert result["status"] == "success"
+                assert result["query"] == test_query
+                return True
+        EOF
+        
+        # Test tool loading and initialization
+        python3 -c '
+        import importlib.util
+        import sys
+        
+        # Load the test tool
+        spec = importlib.util.spec_from_file_location("test_tool", "test_tool.py")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["test_tool"] = module
+        spec.loader.exec_module(module)
+        
+        # Initialize and test the tool
+        tool = module.InternetSearchTool()
+        assert tool.test(), "Tool test failed"
+        print("Custom tool test passed!")
+        ' || exit 1
+        
+        echo "Custom tools integration test passed!"
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        LOGLEVEL: "debug"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Test PraisonAI Agents Configuration
+      continue-on-error: false
+      run: |
+        source .venv/bin/activate
+        
+        # Random sleep between 60-120 seconds to avoid API rate limits
+        SLEEP_TIME=$((RANDOM % 61 + 60))
+        echo "Sleeping for $SLEEP_TIME seconds to avoid API rate limits..."
+        sleep $SLEEP_TIME
+        
+        echo "Testing agents configuration..."
+        mkdir -p test_output || { echo "Failed to create test_output directory"; exit 1; }
+        
+        # Create test script
+        cat > test_agents.py <<EOF
+        from langchain_openai import ChatOpenAI
+        from crewai import Agent, Task, Crew
+        import os
+        import logging
+        import time
+        import random
+
+        logging.basicConfig(level="DEBUG")
+        logger = logging.getLogger(__name__)
+
+        def random_sleep(min_seconds=15, max_seconds=30):
+            """Sleep for a random duration to prevent API rate limiting"""
+            duration = random.uniform(min_seconds, max_seconds)
+            logger.info(f"Rate limit protection: Sleeping for {duration:.2f} seconds...")
+            time.sleep(duration)
+
+        class RateLimitedChatOpenAI(ChatOpenAI):
+            """ChatOpenAI with built-in rate limiting"""
+            def __call__(self, *args, **kwargs):
+                random_sleep()
+                return super().__call__(*args, **kwargs)
+
+        def run_test():
+            logger.info("Initializing test components...")
+            
+            # Initialize the LLM with rate limiting
+            llm = RateLimitedChatOpenAI(
+                model=os.getenv('OPENAI_MODEL_NAME', 'llama-3.3-70b-versatile'),
+                base_url=os.getenv('OPENAI_API_BASE', 'https://api.groq.com/openai/v1/'),
+                api_key=os.getenv('OPENAI_API_KEY'),
+                temperature=0.7
+            )
+
+            random_sleep()
+            logger.info("Creating researcher agent...")
+            researcher = Agent(
+                role="Test Automation Expert",
+                goal="Verify system functionality and performance",
+                backstory="""You are an expert in test automation and system verification,
+                skilled in identifying potential issues and validating functionality.""",
+                verbose=True,
+                allow_delegation=False,
+                llm=llm
+            )
+
+            random_sleep()
+            logger.info("Creating validator agent...")
+            validator = Agent(
+                role="Quality Assurance Specialist",
+                goal="Validate test results and ensure system reliability",
+                backstory="""You are a QA specialist focused on ensuring
+                system reliability and proper functionality.""",
+                verbose=True,
+                allow_delegation=False,
+                llm=llm
+            )
+
+            random_sleep()
+            logger.info("Creating test tasks...")
+            test_task = Task(
+                description="Run a basic system verification test",
+                expected_output="A report on system functionality verification",
+                agent=researcher
+            )
+
+            random_sleep()
+            validation_task = Task(
+                description="Validate the test results and compile findings",
+                expected_output="A validation report of test findings",
+                agent=validator
+            )
+
+            random_sleep()
+            logger.info("Initializing crew...")
+            crew = Crew(
+                agents=[researcher, validator],
+                tasks=[test_task, validation_task],
+                verbose=2
+            )
+
+            logger.info("Starting crew execution...")
+            result = crew.kickoff()
+            logger.info("Test execution completed.")
+            logger.info(f"Result: {result}")
+            return result
+
+        if __name__ == "__main__":
+            try:
+                run_test()
+            except Exception as e:
+                logger.error(f"Test failed with error: {str(e)}", exc_info=True)
+                raise
+        EOF
+        
+        # Run the test script with increased timeout
+        echo "Testing with Python API..."
+        timeout 1800 python3 test_agents.py 2>&1 | tee test_output/agents_test.log
+        
+        # Verify the output
+        if [[ ! -s test_output/agents_test.log ]]; then
+          echo "Error: No output generated from agents test"
+          exit 1
+        fi
+        
+        echo "Agents configuration tests passed!"
+      env:
+        OPENAI_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+        OPENAI_MODEL_NAME: "llama-3.3-70b-versatile"
+        OPENAI_API_BASE: "https://api.groq.com/openai/v1/"
+        OPENAI_API_BASE_URL: "https://api.groq.com/openai/v1/"
+        LOGLEVEL: "debug"
+        PRAISONAI_NON_INTERACTIVE: "true"
+
+    - name: Upload test artifacts
+      if: always()
+      uses: actions/upload-artifact@v3
+      with:
+        name: praisonai-output-${{ matrix.os }}-${{ matrix.framework }}
+        path: test_output/
+        retention-days: 14
+
+  create-release:
+    needs: [test-ubuntu]
+    runs-on: ubuntu-latest
+    if: success()
+    steps:
+    # First checkout the fork's main branch
+    - name: Checkout fork repo
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        token: ${{ secrets.PAT_TOKEN }}
+        repository: ${{ github.event.inputs.fork_owner }}/PraisonAI
+        ref: main
+
+    # Add upstream and get commit from tag
+    - name: Get upstream tag commit
+      id: get_upstream_commit
+      run: |
+        # Add upstream remote
+        git remote add upstream https://github.com/MervinPraison/PraisonAI.git
+        
+        # Delete local tag if it exists
+        git tag -d ${{ github.event.inputs.tag }} || true
+        
+        # Fetch from upstream including tags with force
+        git fetch upstream --tags --force
+        
+        # Verify tag exists in upstream
+        if ! git ls-remote --tags upstream | grep -q "refs/tags/${{ github.event.inputs.tag }}$"; then
+          echo "::error::Tag ${{ github.event.inputs.tag }} not found in upstream repository"
+          exit 1
+        fi
+        
+        # Get the commit hash from the upstream tag
+        UPSTREAM_COMMIT=$(git rev-list -n 1 refs/tags/${{ github.event.inputs.tag }})
+        if [ -z "$UPSTREAM_COMMIT" ]; then
+          echo "::error::Could not find commit for tag ${{ github.event.inputs.tag }}"
+          exit 1
+        fi
+        echo "upstream_commit=$UPSTREAM_COMMIT" >> $GITHUB_OUTPUT
+        echo "Found commit: $UPSTREAM_COMMIT for tag ${{ github.event.inputs.tag }}"
+
+    # Create tag at the same commit
+    - name: Create tag at commit
+      run: |
+        git config --global user.name "GitHub Actions"
+        git config --global user.email "[email protected]"
+        
+        # Remove tag if it exists locally
+        git tag -d ${{ github.event.inputs.tag }} || true
+        
+        # Remove tag if it exists remotely
+        git push origin :refs/tags/${{ github.event.inputs.tag }} || true
+        
+        # Fetch the specific commit from upstream
+        git fetch upstream ${{ steps.get_upstream_commit.outputs.upstream_commit }} --force
+        
+        # Reset to upstream commit
+        git reset --hard ${{ steps.get_upstream_commit.outputs.upstream_commit }}
+        
+        # Create and push tag
+        git tag -a ${{ github.event.inputs.tag }} -m "Release ${{ github.event.inputs.tag }} (synced from upstream MervinPraison/PraisonAI@${{ github.event.inputs.tag }})"
+        git push origin ${{ github.event.inputs.tag }}
+      env:
+        GIT_ASKPASS: /bin/echo
+        PAT_TOKEN: ${{ secrets.PAT_TOKEN }}
+
+    # Create the release
+    - name: Create Release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.PAT_TOKEN }}
+      with:
+        tag_name: ${{ github.event.inputs.tag }}
+        release_name: Release ${{ github.event.inputs.tag }}
+        draft: false
+        prerelease: false
+        body: |
+          Release ${{ github.event.inputs.tag }} (synced from upstream)
+          
+          This release is synchronized with MervinPraison/PraisonAI@${{ github.event.inputs.tag }}
+          Commit: ${{ steps.get_upstream_commit.outputs.upstream_commit }}
+          
+          For installation:
+          ```bash
+          pip install praisonai
+          ```
+          
+          Changes from upstream v2.0.10:
+          - Updated agent configuration tests
+          - Added rate limiting protection
+          - Improved test reliability
+          
+          Forked from: MervinPraison/PraisonAI

.github/workflows/unittest.yml

@@ -0,0 +1,36 @@
+name: Run specific unittest
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.11
+
+    - name: Install Poetry
+      run: |
+        curl -sSL https://install.python-poetry.org | python3 -
+        export PATH="$HOME/.local/bin:$PATH"
+
+    - name: Install dependencies
+      run: |
+        poetry install
+        poetry run python -m pip install duckduckgo_search
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME }}" >> $GITHUB_ENV
+
+    - name: Run specific unittest
+      run: |
+        poetry run python -m unittest tests.test.TestExamples

.gitignore

@@ -0,0 +1,69 @@
+.vscode
+crewai
+.cache
+__pycache__
+chroma.sqlite3
+test
+dist
+.env
+assets
+.idea
+.DS_Store
+.pytest_cache
+praisonAI.egg-info
+flagged
+test.yaml
+db
+praisonai_prompt.txt
+watch.sh
+docs.sh
+other
+output
+
+.files
+threads.db
+threads.db-journal
+
+.chainlit
+!praisonai/ui/config/.chainlit
+
+site
+# Ignore Sphinx build directory
+docs/_build/
+docs/source/
+docs/build/
+
+# Ignore Sphinx cache
+docs/_build/doctrees/
+docs/_build/doctrees/*
+docs/_build/doctrees/.doctrees
+
+# Ignore Sphinx logs and local build files
+docs/_build/.buildinfo
+docs/_build/.buildinfo/*
+docs/_build/.buildinfo/.buildinfo
+
+praisonai/doc
+
+# agentops
+trained_agents_data.pkl
+agentops.log
+
+# crewAI
+crewAI
+
+# virtualenv
+.venv
+
+# Credentials
+credentials.json
+
+# node_modules
+node_modules
+
+outputs
+agents/praisonaiagents/build
+agents/praisonaiagents/dist
+agents/praisonaiagents/praisonaiagents.egg-info
+.codegpt
+.praison

.praisoncontext

@@ -0,0 +1,4 @@
+# praisonai/ui/context.py
+# /Users/praison/miniconda3/envs/praisonai-package/lib/python3.11/site-packages/llama_index/packs/code_hierarchy/code_hierarchy.py
+praisonai/ui/components/aicoder.py
+praisonai/ui/code.py

.praisonignore

@@ -0,0 +1,4 @@
+cookbooks
+tests
+docs
+praisonai/inbuilt_tools/*

.praisoninclude

@@ -0,0 +1,3 @@
+# praisonai/ui/context.py
+# /Users/praison/miniconda3/envs/praisonai-package/lib/python3.11/site-packages/llama_index/packs/code_hierarchy/code_hierarchy.py
+praisonai/setup

.readthedocs.yml

@@ -0,0 +1,23 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+  jobs:
+    post_install:
+    - bash docs/generate_docs.sh
+
+mkdocs:
+  configuration: mkdocs.yml
+  fail_on_warning: true
+
+python:
+  install:
+    - requirements: docs/requirements.txt

Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY . .
+RUN pip install flask praisonai==2.0.45 gunicorn markdown
+EXPOSE 8080
+CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

Dockerfile.chat

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python packages
+RUN pip install --no-cache-dir \
+    praisonaiagents>=0.0.4 \
+    praisonai_tools \
+    "praisonai==2.0.18" \
+    "praisonai[chat]" \
+    "embedchain[github,youtube]"
+
+# Copy application code
+COPY . .
+
+# Default command (will be overridden by docker-compose)
+CMD ["praisonai", "chat"]

Dockerfile.dev

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    portaudio19-dev \
+    python3-pyaudio \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python packages
+RUN pip install --no-cache-dir \
+    praisonaiagents>=0.0.4 \
+    praisonai_tools \
+    "praisonai==2.0.18" \
+    "praisonai[ui]" \
+    "praisonai[chat]" \
+    "praisonai[realtime]" \
+    "embedchain[github,youtube]"
+
+# Copy application code
+COPY . .
+
+# Default command (will be overridden by docker-compose)
+CMD ["praisonai", "ui"]

Dockerfile.ui

@@ -0,0 +1,24 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python packages
+RUN pip install --no-cache-dir \
+    praisonaiagents>=0.0.4 \
+    praisonai_tools \
+    "praisonai==2.0.18" \
+    "praisonai[ui]" \
+    "praisonai[crewai]"
+
+# Copy application code
+COPY . .
+
+# Default command (will be overridden by docker-compose)
+CMD ["praisonai", "ui"]

LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,582 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/logo/dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="docs/logo/light.png" />
+    <img alt="PraisonAI Logo" src="docs/logo/light.png" />
+  </picture>
+</p>
+
+<p align="center">
+<a href="https://github.com/MervinPraison/PraisonAI"><img src="https://static.pepy.tech/badge/PraisonAI" alt="Total Downloads" /></a>
+<a href="https://github.com/MervinPraison/PraisonAI"><img src="https://img.shields.io/github/v/release/MervinPraison/PraisonAI" alt="Latest Stable Version" /></a>
+<a href="https://github.com/MervinPraison/PraisonAI"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License" /></a>
+</p>
+
+<div align="center">
+
+# Praison AI
+
+<a href="https://trendshift.io/repositories/9130" target="_blank"><img src="https://trendshift.io/api/badge/repositories/9130" alt="MervinPraison%2FPraisonAI | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+</div>
+
+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.
+
+<div align="center">
+  <a href="https://docs.praison.ai">
+    <p align="center">
+      <img src="https://img.shields.io/badge/📚_Documentation-Visit_docs.praison.ai-blue?style=for-the-badge&logo=bookstack&logoColor=white" alt="Documentation" />
+    </p>
+  </a>
+</div>
+
+## Key Features
+
+- 🤖 Automated AI Agents Creation
+- 🔄 Self Reflection AI Agents
+- 🧠 Reasoning AI Agents
+- 👁️ Multi Modal AI Agents
+- 🤝 Multi Agent Collaboration
+- ⚡ AI Agent Workflow
+- 🔄 Use CrewAI or AutoGen Framework
+- 💯 100+ LLM Support
+- 💻 Chat with ENTIRE Codebase
+- 🎨 Interactive UIs
+- 📄 YAML-based Configuration
+- 🛠️ Custom Tool Integration
+- 🔍 Internet Search Capability (using Crawl4AI and Tavily)
+- 🖼️ Vision Language Model (VLM) Support
+- 🎙️ Real-time Voice Interaction
+
+## Using No Code
+
+### Auto Mode:
+```bash
+pip install praisonai
+export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+praisonai --auto create a movie script about Robots in Mars
+```
+
+### Initialise Mode:
+```bash
+pip install praisonai
+export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+praisonai --init create a movie script about Robots in Mars
+praisonai
+```
+
+## Using Coding
+
+Light weight package dedicated for coding:
+```bash
+pip install praisonaiagents
+```
+
+```bash
+export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+```
+
+Create app.py file and add the code below:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# 1. Create agents
+researcher = Agent(
+    name="Researcher",
+    role="Senior Research Analyst",
+    goal="Uncover cutting-edge developments in AI and data science",
+    backstory="""You are an expert at a technology research group, 
+    skilled in identifying trends and analyzing complex data.""",
+    verbose=True,
+    llm="gpt-4o",
+    markdown=True
+)
+writer = Agent(
+    name="Writer",
+    role="Tech Content Strategist",
+    goal="Craft compelling content on tech advancements",
+    backstory="""You are a content strategist known for 
+    making complex tech topics interesting and easy to understand.""",
+    llm="gpt-4o",
+    markdown=True
+)
+
+# 2. Define Tasks
+task1 = Task(
+    name="research_task",
+    description="""Analyze 2024's AI advancements. 
+    Find major trends, new technologies, and their effects.""",
+    expected_output="""A detailed report on 2024 AI advancements""",
+    agent=researcher
+)
+
+task2 = Task(
+    name="writing_task",
+    description="""Create a blog post about major AI advancements using the insights you have.
+    Make it interesting, clear, and suited for tech enthusiasts. 
+    It should be at least 4 paragraphs long.""",
+    expected_output="A blog post of at least 4 paragraphs",
+    agent=writer,
+)
+
+agents = PraisonAIAgents(
+    agents=[researcher, writer],
+    tasks=[task1, task2],
+    verbose=False,
+    process="hierarchical",
+    manager_llm="gpt-4o"
+)
+
+result = agents.start()
+```
+
+Run:
+```bash
+python app.py
+```
+
+## Ollama Integration
+```bash
+export OPENAI_BASE_URL=http://localhost:11434/v1
+```
+
+## Groq Integration
+Replace xxxx with Groq API KEY:
+```bash
+export OPENAI_API_KEY=xxxxxxxxxxx
+export OPENAI_BASE_URL=https://api.groq.com/openai/v1
+```
+
+## Logging
+```bash
+export LOGLEVEL=info
+```
+
+Advanced logging:
+```bash
+export LOGLEVEL=debug
+```
+
+<div align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/images/architecture-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="docs/images/architecture-light.png" />
+    <img alt="PraisonAI Architecture" src="docs/images/architecture-light.png" />
+  </picture>
+</div>
+
+## Different User Interfaces:
+
+| Interface | Description | URL |
+|---|---|---|
+| **UI** | Multi Agents such as CrewAI or AutoGen | [https://docs.praison.ai/ui/ui](https://docs.praison.ai/ui/ui) |
+| **Chat** | Chat with 100+ LLMs, single AI Agent | [https://docs.praison.ai/ui/chat](https://docs.praison.ai/ui/chat) |
+| **Code** | Chat with entire Codebase, single AI Agent | [https://docs.praison.ai/ui/code](https://docs.praison.ai/ui/code) |
+| **Realtime** | Real-time voice interaction with AI | [https://docs.praison.ai/ui/realtime](https://docs.praison.ai/ui/realtime) |
+
+| Other Features | Description | Docs |
+|---|---|---|
+| **Train** | Fine-tune LLMs using your custom data | [https://docs.praison.ai/train](https://docs.praison.ai/train) |
+
+
+## Google Colab Multi Agents
+
+|               | Cookbook        | Open in Colab                                                                                                                                                                                                                                  |
+| ------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Basic         | PraisonAI       | <a target="_blank" href="https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/cookbooks/praisonai-googlecolab.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" /></a>       |
+| Include Tools | PraisonAI Tools | <a target="_blank" href="https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/cookbooks/praisonai-tools-googlecolab.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" /></a> |
+
+## Installation Options
+
+### Using pip
+```bash
+pip install praisonai
+```
+
+### Framework-specific Installation
+```bash
+# Install with CrewAI support
+pip install "praisonai[crewai]"
+
+# Install with AutoGen support
+pip install "praisonai[autogen]"
+
+# Install with both frameworks
+pip install "praisonai[crewai,autogen]"
+```
+
+### UI and Additional Features
+```bash
+# Install UI support
+pip install "praisonai[ui]"
+
+# Install Chat interface
+pip install "praisonai[chat]"
+
+# Install Code interface
+pip install "praisonai[code]"
+
+# Install Realtime voice interaction
+pip install "praisonai[realtime]"
+
+# Install Call feature
+pip install "praisonai[call]"
+```
+
+## Quick Start
+
+```bash
+# Set your OpenAI API key
+export OPENAI_API_KEY="Enter your API key"
+
+# Initialize with CrewAI (default)
+praisonai --init "create a movie script about dog in moon"
+
+# Or initialize with AutoGen
+praisonai --framework autogen --init "create a movie script about dog in moon"
+
+# Run the agents
+praisonai
+```
+
+## Full Automatic Mode
+
+```bash
+# With CrewAI (default)
+praisonai --auto "create a movie script about Dog in Moon"
+
+# With AutoGen
+praisonai --framework autogen --auto "create a movie script about Dog in Moon"
+```
+
+## Framework-specific Features
+
+### CrewAI
+When installing with `pip install "praisonai[crewai]"`, you get:
+- CrewAI framework support
+- PraisonAI tools integration
+- Task delegation capabilities
+- Sequential and parallel task execution
+
+### AutoGen
+When installing with `pip install "praisonai[autogen]"`, you get:
+- AutoGen framework support
+- PraisonAI tools integration
+- Multi-agent conversation capabilities
+- Code execution environment
+
+
+
+## TL;DR Multi Agents
+
+```bash
+pip install praisonai
+export OPENAI_API_KEY="Enter your API key"
+praisonai --init create a movie script about dog in moon
+praisonai
+```
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Initialise](#initialise)
+- [Run](#run)
+- [Full Automatic Mode](#full-automatic-mode)
+- [User Interface](#user-interface)
+- [Praison AI Chat](#praison-ai-chat)
+- [Create Custom Tools](#create-custom-tools)
+- [Agents Playbook](#agents-playbook)
+- [Include praisonai package in your project](#include-praisonai-package-in-your-project)
+- [Commands to Install Dev Dependencies](#commands-to-install-dependencies)
+- [Other Models](#other-models)
+- [Contributing](#contributing)
+- [Star History](#star-history)
+
+## Installation Multi Agents
+
+```bash
+pip install praisonai
+```
+
+## Initialise
+
+```bash
+export OPENAI_API_KEY="Enter your API key"
+```
+
+Generate your OPENAI API KEY from here: https://platform.openai.com/api-keys
+
+Note: You can use other providers such as Ollama, Mistral ... etc. Details are provided at the bottom.
+
+```bash
+praisonai --init create a movie script about dog in moon
+```
+
+This will automatically create agents.yaml file in the current directory.
+
+### To initialise with a specific agent framework (Optional):
+
+```bash
+praisonai --framework autogen --init create movie script about cat in mars
+```
+
+## Run
+
+```bash
+praisonai
+```
+
+or
+
+```bash
+python -m praisonai
+```
+
+### Specify the agent framework (Optional):
+
+```bash
+praisonai --framework autogen
+```
+
+### Full Automatic Mode
+
+```bash
+praisonai --auto create a movie script about Dog in Moon
+```
+
+## User Interface
+
+## PraisonAI User Interfaces:
+
+| Interface | Description                                | URL                                                                   |
+| --------- | ------------------------------------------ | --------------------------------------------------------------------- |
+| **UI**    | Multi Agents such as CrewAI or AutoGen     | [https://docs.praisonai.com/ui/ui](https://docs.praison.ai/ui/ui)     |
+| **Chat**  | Chat with 100+ LLMs, single AI Agent       | [https://docs.praisonai.com/ui/chat](https://docs.praison.ai/ui/chat) |
+| **Code**  | Chat with entire Codebase, single AI Agent | [https://docs.praisonai.com/ui/code](https://docs.praison.ai/ui/code) |
+
+```bash
+pip install -U "praisonai[ui]"
+export OPENAI_API_KEY="Enter your API key"
+chainlit create-secret
+export CHAINLIT_AUTH_SECRET=xxxxxxxx
+praisonai ui
+```
+
+or
+
+```
+python -m praisonai ui
+```
+
+## Praison AI Chat
+
+- https://docs.praison.ai/chat/
+
+```bash
+pip install "praisonai[chat]"
+export OPENAI_API_KEY="Enter your API key"
+praisonai chat
+```
+
+### Internet Search
+
+Praison AI Chat and Praison AI Code now includes internet search capabilities using Crawl4AI and Tavily, allowing you to retrieve up-to-date information during your conversations.
+
+### Vision Language Model Support
+
+You can now upload images and ask questions based on them using Vision Language Models. This feature enables visual understanding and analysis within your chat sessions.
+
+## Praison AI Code
+
+```bash
+pip install "praisonai[code]"
+export OPENAI_API_KEY="Enter your API key"
+praisonai code
+```
+
+### Internet Search
+
+Praison AI Code also includes internet search functionality, enabling you to find relevant code snippets and programming information online.
+
+## Create Custom Tools
+
+- https://docs.praison.ai/tools/custom/
+
+## Agents Playbook
+
+### Simple Playbook Example
+
+```yaml
+framework: crewai
+topic: Artificial Intelligence
+roles:
+  screenwriter:
+    backstory: "Skilled in crafting scripts with engaging dialogue about {topic}."
+    goal: Create scripts from concepts.
+    role: Screenwriter
+    tasks:
+      scriptwriting_task:
+        description: "Develop scripts with compelling characters and dialogue about {topic}."
+        expected_output: "Complete script ready for production."
+```
+
+## Use 100+ Models
+
+- https://docs.praison.ai/models/
+
+## Include praisonai package in your project
+
+- https://docs.praison.ai/developers/wrapper
+- https://docs.praison.ai/developers/wrapper-tools/
+
+## Option 1: Using RAW YAML
+
+```python
+from praisonai import PraisonAI
+
+# Example agent_yaml content
+agent_yaml = """
+framework: "crewai"
+topic: "Space Exploration"
+
+roles:
+  astronomer:
+    role: "Space Researcher"
+    goal: "Discover new insights about {topic}"
+    backstory: "You are a curious and dedicated astronomer with a passion for unraveling the mysteries of the cosmos."
+    tasks:
+      investigate_exoplanets:
+        description: "Research and compile information about exoplanets discovered in the last decade."
+        expected_output: "A summarized report on exoplanet discoveries, including their size, potential habitability, and distance from Earth."
+"""
+
+# Create a PraisonAI instance with the agent_yaml content
+praisonai = PraisonAI(agent_yaml=agent_yaml)
+
+# Run PraisonAI
+result = praisonai.run()
+
+# Print the result
+print(result)
+```
+
+## Option 2: Using separate agents.yaml file
+
+Note: Please create agents.yaml file before hand.
+
+```python
+from praisonai import PraisonAI
+
+def basic(): # Basic Mode
+    praisonai = PraisonAI(agent_file="agents.yaml")
+    praisonai.run()
+
+if __name__ == "__main__":
+    basic()
+```
+
+## Commands to Install Dependencies:
+
+### Using uv
+```bash
+# Install uv if you haven't already
+pip install uv
+
+# Install from requirements
+uv pip install -r pyproject.toml
+
+# Install with extras
+uv pip install -r pyproject.toml --extra code
+uv pip install -r pyproject.toml --extra "crewai,autogen"
+```
+
+## Contributing
+
+- Fork on GitHub: Use the "Fork" button on the repository page.
+- Clone your fork: `git clone https://github.com/yourusername/praisonAI.git`
+- Create a branch: `git checkout -b new-feature`
+- Make changes and commit: `git commit -am "Add some feature"`
+- Push to your fork: `git push origin new-feature`
+- Submit a pull request via GitHub's web interface.
+- Await feedback from project maintainers.
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=MervinPraison/PraisonAI&type=Date)](https://docs.praison.ai)
+
+## License
+
+Praison AI is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
+
+## Video Tutorials
+
+| Topic | Video |
+|-------|--------|
+| Introduction | [![Introduction](https://img.youtube.com/vi/Fn1lQjC0GO0/0.jpg)](https://www.youtube.com/watch?v=Fn1lQjC0GO0) |
+| Tools Overview | [![Tools Overview](https://img.youtube.com/vi/XaQRgRpV7jo/0.jpg)](https://www.youtube.com/watch?v=XaQRgRpV7jo) |
+| Custom Tools | [![Custom Tools](https://img.youtube.com/vi/JSU2Rndh06c/0.jpg)](https://www.youtube.com/watch?v=JSU2Rndh06c) |
+| Firecrawl Integration | [![Firecrawl](https://img.youtube.com/vi/UoqUDcLcOYo/0.jpg)](https://www.youtube.com/watch?v=UoqUDcLcOYo) |
+| User Interface | [![UI](https://img.youtube.com/vi/tg-ZjNl3OCg/0.jpg)](https://www.youtube.com/watch?v=tg-ZjNl3OCg) |
+| Crawl4AI Integration | [![Crawl4AI](https://img.youtube.com/vi/KAvuVUh0XU8/0.jpg)](https://www.youtube.com/watch?v=KAvuVUh0XU8) |
+| Chat Interface | [![Chat](https://img.youtube.com/vi/sw3uDqn2h1Y/0.jpg)](https://www.youtube.com/watch?v=sw3uDqn2h1Y) |
+| Code Interface | [![Code](https://img.youtube.com/vi/_5jQayO-MQY/0.jpg)](https://www.youtube.com/watch?v=_5jQayO-MQY) |
+| Mem0 Integration | [![Mem0](https://img.youtube.com/vi/KIGSgRxf1cY/0.jpg)](https://www.youtube.com/watch?v=KIGSgRxf1cY) |
+| Training | [![Training](https://img.youtube.com/vi/aLawE8kwCrI/0.jpg)](https://www.youtube.com/watch?v=aLawE8kwCrI) |
+| Realtime Voice Interface | [![Realtime](https://img.youtube.com/vi/frRHfevTCSw/0.jpg)](https://www.youtube.com/watch?v=frRHfevTCSw) |
+| Call Interface | [![Call](https://img.youtube.com/vi/m1cwrUG2iAk/0.jpg)](https://www.youtube.com/watch?v=m1cwrUG2iAk) |
+
+## License
+
+Praison AI is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
+
+## Local Docker Development with Live Reload
+
+To facilitate local development with live reload, you can use Docker. Follow the steps below:
+
+1. **Create a `Dockerfile.dev`**:
+    ```dockerfile
+    FROM python:3.11-slim
+
+    WORKDIR /app
+
+    COPY . .
+
+    RUN pip install flask praisonai==2.0.18 watchdog
+
+    EXPOSE 5555
+
+    ENV FLASK_ENV=development
+
+    CMD ["flask", "run", "--host=0.0.0.0"]
+    ```
+
+2. **Create a `docker-compose.yml`**:
+    ```yaml
+    version: '3.8'
+
+    services:
+      app:
+        build:
+          context: .
+          dockerfile: Dockerfile.dev
+        volumes:
+          - .:/app
+        ports:
+          - "5555:5555"
+        environment:
+          FLASK_ENV: development
+        command: flask run --host=0.0.0.0
+
+      watch:
+        image: alpine:latest
+        volumes:
+          - .:/app
+        command: sh -c "apk add --no-cache inotify-tools && while inotifywait -r -e modify,create,delete /app; do kill -HUP 1; done"
+    ```
+
+3. **Run Docker Compose**:
+    ```bash
+    docker-compose up
+    ```
+
+This setup will allow you to develop locally with live reload, making it easier to test and iterate on your code.

_build/html/_sources/index.rst.txt

@@ -1,20 +0,0 @@
-.. PraisonAI documentation master file, created by
-   sphinx-quickstart on Mon Jun 10 12:11:57 2024.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-Welcome to PraisonAI's documentation!
-=====================================
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`

_build/html/_sources/source/modules.rst.txt

@@ -1,7 +0,0 @@
-praisonai
-=========
-
-.. toctree::
-   :maxdepth: 4
-
-   praisonai

_build/html/_sources/source/praisonai.inbuilt_tools.rst.txt

@@ -1,21 +0,0 @@
-praisonai.inbuilt\_tools package
-================================
-
-Submodules
-----------
-
-praisonai.inbuilt\_tools.autogen\_tools module
-----------------------------------------------
-
-.. automodule:: praisonai.inbuilt_tools.autogen_tools
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-Module contents
----------------
-
-.. automodule:: praisonai.inbuilt_tools
-   :members:
-   :undoc-members:
-   :show-inheritance:

_build/html/_sources/source/praisonai.rst.txt

@@ -1,69 +0,0 @@
-praisonai package
-=================
-
-Subpackages
------------
-
-.. toctree::
-   :maxdepth: 4
-
-   praisonai.inbuilt_tools
-
-Submodules
-----------
-
-praisonai.agents\_generator module
-----------------------------------
-
-.. automodule:: praisonai.agents_generator
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-praisonai.auto module
----------------------
-
-.. automodule:: praisonai.auto
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-praisonai.cli module
---------------------
-
-.. automodule:: praisonai.cli
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-praisonai.deploy module
------------------------
-
-.. automodule:: praisonai.deploy
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-praisonai.test module
----------------------
-
-.. automodule:: praisonai.test
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-praisonai.version module
-------------------------
-
-.. automodule:: praisonai.version
-   :members:
-   :undoc-members:
-   :show-inheritance:
-
-Module contents
----------------
-
-.. automodule:: praisonai
-   :members:
-   :undoc-members:
-   :show-inheritance:

_build/html/_static/_sphinx_javascript_frameworks_compat.js

@@ -1,123 +0,0 @@
-/* Compatability shim for jQuery and underscores.js.
- *
- * Copyright Sphinx contributors
- * Released under the two clause BSD licence
- */
-
-/**
- * small helper function to urldecode strings
- *
- * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
- */
-jQuery.urldecode = function(x) {
-    if (!x) {
-        return x
-    }
-    return decodeURIComponent(x.replace(/\+/g, ' '));
-};
-
-/**
- * small helper function to urlencode strings
- */
-jQuery.urlencode = encodeURIComponent;
-
-/**
- * This function returns the parsed url parameters of the
- * current request. Multiple values per key are supported,
- * it will always return arrays of strings for the value parts.
- */
-jQuery.getQueryParameters = function(s) {
-    if (typeof s === 'undefined')
-        s = document.location.search;
-    var parts = s.substr(s.indexOf('?') + 1).split('&');
-    var result = {};
-    for (var i = 0; i < parts.length; i++) {
-        var tmp = parts[i].split('=', 2);
-        var key = jQuery.urldecode(tmp[0]);
-        var value = jQuery.urldecode(tmp[1]);
-        if (key in result)
-            result[key].push(value);
-        else
-            result[key] = [value];
-    }
-    return result;
-};
-
-/**
- * highlight a given string on a jquery object by wrapping it in
- * span elements with the given class name.
- */
-jQuery.fn.highlightText = function(text, className) {
-    function highlight(node, addItems) {
-        if (node.nodeType === 3) {
-            var val = node.nodeValue;
-            var pos = val.toLowerCase().indexOf(text);
-            if (pos >= 0 &&
-                !jQuery(node.parentNode).hasClass(className) &&
-                !jQuery(node.parentNode).hasClass("nohighlight")) {
-                var span;
-                var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
-                if (isInSVG) {
-                    span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
-                } else {
-                    span = document.createElement("span");
-                    span.className = className;
-                }
-                span.appendChild(document.createTextNode(val.substr(pos, text.length)));
-                node.parentNode.insertBefore(span, node.parentNode.insertBefore(
-                    document.createTextNode(val.substr(pos + text.length)),
-                    node.nextSibling));
-                node.nodeValue = val.substr(0, pos);
-                if (isInSVG) {
-                    var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-                    var bbox = node.parentElement.getBBox();
-                    rect.x.baseVal.value = bbox.x;
-                    rect.y.baseVal.value = bbox.y;
-                    rect.width.baseVal.value = bbox.width;
-                    rect.height.baseVal.value = bbox.height;
-                    rect.setAttribute('class', className);
-                    addItems.push({
-                        "parent": node.parentNode,
-                        "target": rect});
-                }
-            }
-        }
-        else if (!jQuery(node).is("button, select, textarea")) {
-            jQuery.each(node.childNodes, function() {
-                highlight(this, addItems);
-            });
-        }
-    }
-    var addItems = [];
-    var result = this.each(function() {
-        highlight(this, addItems);
-    });
-    for (var i = 0; i < addItems.length; ++i) {
-        jQuery(addItems[i].parent).before(addItems[i].target);
-    }
-    return result;
-};
-
-/*
- * backward compatibility for jQuery.browser
- * This will be supported until firefox bug is fixed.
- */
-if (!jQuery.browser) {
-    jQuery.uaMatch = function(ua) {
-        ua = ua.toLowerCase();
-
-        var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
-            /(webkit)[ \/]([\w.]+)/.exec(ua) ||
-            /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
-            /(msie) ([\w.]+)/.exec(ua) ||
-            ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
-            [];
-
-        return {
-            browser: match[ 1 ] || "",
-            version: match[ 2 ] || "0"
-        };
-    };
-    jQuery.browser = {};
-    jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
-}

_build/html/_static/alabaster.css

@@ -1,708 +0,0 @@
-@import url("basic.css");
-
-/* -- page layout ----------------------------------------------------------- */
-
-body {
-    font-family: Georgia, serif;
-    font-size: 17px;
-    background-color: #fff;
-    color: #000;
-    margin: 0;
-    padding: 0;
-}
-
-
-div.document {
-    width: 940px;
-    margin: 30px auto 0 auto;
-}
-
-div.documentwrapper {
-    float: left;
-    width: 100%;
-}
-
-div.bodywrapper {
-    margin: 0 0 0 220px;
-}
-
-div.sphinxsidebar {
-    width: 220px;
-    font-size: 14px;
-    line-height: 1.5;
-}
-
-hr {
-    border: 1px solid #B1B4B6;
-}
-
-div.body {
-    background-color: #fff;
-    color: #3E4349;
-    padding: 0 30px 0 30px;
-}
-
-div.body > .section {
-    text-align: left;
-}
-
-div.footer {
-    width: 940px;
-    margin: 20px auto 30px auto;
-    font-size: 14px;
-    color: #888;
-    text-align: right;
-}
-
-div.footer a {
-    color: #888;
-}
-
-p.caption {
-    font-family: inherit;
-    font-size: inherit;
-}
-
-
-div.relations {
-    display: none;
-}
-
-
-div.sphinxsidebar {
-    max-height: 100%;
-    overflow-y: auto;
-}
-
-div.sphinxsidebar a {
-    color: #444;
-    text-decoration: none;
-    border-bottom: 1px dotted #999;
-}
-
-div.sphinxsidebar a:hover {
-    border-bottom: 1px solid #999;
-}
-
-div.sphinxsidebarwrapper {
-    padding: 18px 10px;
-}
-
-div.sphinxsidebarwrapper p.logo {
-    padding: 0;
-    margin: -10px 0 0 0px;
-    text-align: center;
-}
-
-div.sphinxsidebarwrapper h1.logo {
-    margin-top: -10px;
-    text-align: center;
-    margin-bottom: 5px;
-    text-align: left;
-}
-
-div.sphinxsidebarwrapper h1.logo-name {
-    margin-top: 0px;
-}
-
-div.sphinxsidebarwrapper p.blurb {
-    margin-top: 0;
-    font-style: normal;
-}
-
-div.sphinxsidebar h3,
-div.sphinxsidebar h4 {
-    font-family: Georgia, serif;
-    color: #444;
-    font-size: 24px;
-    font-weight: normal;
-    margin: 0 0 5px 0;
-    padding: 0;
-}
-
-div.sphinxsidebar h4 {
-    font-size: 20px;
-}
-
-div.sphinxsidebar h3 a {
-    color: #444;
-}
-
-div.sphinxsidebar p.logo a,
-div.sphinxsidebar h3 a,
-div.sphinxsidebar p.logo a:hover,
-div.sphinxsidebar h3 a:hover {
-    border: none;
-}
-
-div.sphinxsidebar p {
-    color: #555;
-    margin: 10px 0;
-}
-
-div.sphinxsidebar ul {
-    margin: 10px 0;
-    padding: 0;
-    color: #000;
-}
-
-div.sphinxsidebar ul li.toctree-l1 > a {
-    font-size: 120%;
-}
-
-div.sphinxsidebar ul li.toctree-l2 > a {
-    font-size: 110%;
-}
-
-div.sphinxsidebar input {
-    border: 1px solid #CCC;
-    font-family: Georgia, serif;
-    font-size: 1em;
-}
-
-div.sphinxsidebar #searchbox input[type="text"] {
-    width: 160px;
-}
-
-div.sphinxsidebar .search > div {
-    display: table-cell;
-}
-
-div.sphinxsidebar hr {
-    border: none;
-    height: 1px;
-    color: #AAA;
-    background: #AAA;
-
-    text-align: left;
-    margin-left: 0;
-    width: 50%;
-}
-
-div.sphinxsidebar .badge {
-    border-bottom: none;
-}
-
-div.sphinxsidebar .badge:hover {
-    border-bottom: none;
-}
-
-/* To address an issue with donation coming after search */
-div.sphinxsidebar h3.donation {
-    margin-top: 10px;
-}
-
-/* -- body styles ----------------------------------------------------------- */
-
-a {
-    color: #004B6B;
-    text-decoration: underline;
-}
-
-a:hover {
-    color: #6D4100;
-    text-decoration: underline;
-}
-
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
-    font-family: Georgia, serif;
-    font-weight: normal;
-    margin: 30px 0px 10px 0px;
-    padding: 0;
-}
-
-div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
-div.body h2 { font-size: 180%; }
-div.body h3 { font-size: 150%; }
-div.body h4 { font-size: 130%; }
-div.body h5 { font-size: 100%; }
-div.body h6 { font-size: 100%; }
-
-a.headerlink {
-    color: #DDD;
-    padding: 0 4px;
-    text-decoration: none;
-}
-
-a.headerlink:hover {
-    color: #444;
-    background: #EAEAEA;
-}
-
-div.body p, div.body dd, div.body li {
-    line-height: 1.4em;
-}
-
-div.admonition {
-    margin: 20px 0px;
-    padding: 10px 30px;
-    background-color: #EEE;
-    border: 1px solid #CCC;
-}
-
-div.admonition tt.xref, div.admonition code.xref, div.admonition a tt {
-    background-color: #FBFBFB;
-    border-bottom: 1px solid #fafafa;
-}
-
-div.admonition p.admonition-title {
-    font-family: Georgia, serif;
-    font-weight: normal;
-    font-size: 24px;
-    margin: 0 0 10px 0;
-    padding: 0;
-    line-height: 1;
-}
-
-div.admonition p.last {
-    margin-bottom: 0;
-}
-
-div.highlight {
-    background-color: #fff;
-}
-
-dt:target, .highlight {
-    background: #FAF3E8;
-}
-
-div.warning {
-    background-color: #FCC;
-    border: 1px solid #FAA;
-}
-
-div.danger {
-    background-color: #FCC;
-    border: 1px solid #FAA;
-    -moz-box-shadow: 2px 2px 4px #D52C2C;
-    -webkit-box-shadow: 2px 2px 4px #D52C2C;
-    box-shadow: 2px 2px 4px #D52C2C;
-}
-
-div.error {
-    background-color: #FCC;
-    border: 1px solid #FAA;
-    -moz-box-shadow: 2px 2px 4px #D52C2C;
-    -webkit-box-shadow: 2px 2px 4px #D52C2C;
-    box-shadow: 2px 2px 4px #D52C2C;
-}
-
-div.caution {
-    background-color: #FCC;
-    border: 1px solid #FAA;
-}
-
-div.attention {
-    background-color: #FCC;
-    border: 1px solid #FAA;
-}
-
-div.important {
-    background-color: #EEE;
-    border: 1px solid #CCC;
-}
-
-div.note {
-    background-color: #EEE;
-    border: 1px solid #CCC;
-}
-
-div.tip {
-    background-color: #EEE;
-    border: 1px solid #CCC;
-}
-
-div.hint {
-    background-color: #EEE;
-    border: 1px solid #CCC;
-}
-
-div.seealso {
-    background-color: #EEE;
-    border: 1px solid #CCC;
-}
-
-div.topic {
-    background-color: #EEE;
-}
-
-p.admonition-title {
-    display: inline;
-}
-
-p.admonition-title:after {
-    content: ":";
-}
-
-pre, tt, code {
-    font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-    font-size: 0.9em;
-}
-
-.hll {
-    background-color: #FFC;
-    margin: 0 -12px;
-    padding: 0 12px;
-    display: block;
-}
-
-img.screenshot {
-}
-
-tt.descname, tt.descclassname, code.descname, code.descclassname {
-    font-size: 0.95em;
-}
-
-tt.descname, code.descname {
-    padding-right: 0.08em;
-}
-
-img.screenshot {
-    -moz-box-shadow: 2px 2px 4px #EEE;
-    -webkit-box-shadow: 2px 2px 4px #EEE;
-    box-shadow: 2px 2px 4px #EEE;
-}
-
-table.docutils {
-    border: 1px solid #888;
-    -moz-box-shadow: 2px 2px 4px #EEE;
-    -webkit-box-shadow: 2px 2px 4px #EEE;
-    box-shadow: 2px 2px 4px #EEE;
-}
-
-table.docutils td, table.docutils th {
-    border: 1px solid #888;
-    padding: 0.25em 0.7em;
-}
-
-table.field-list, table.footnote {
-    border: none;
-    -moz-box-shadow: none;
-    -webkit-box-shadow: none;
-    box-shadow: none;
-}
-
-table.footnote {
-    margin: 15px 0;
-    width: 100%;
-    border: 1px solid #EEE;
-    background: #FDFDFD;
-    font-size: 0.9em;
-}
-
-table.footnote + table.footnote {
-    margin-top: -15px;
-    border-top: none;
-}
-
-table.field-list th {
-    padding: 0 0.8em 0 0;
-}
-
-table.field-list td {
-    padding: 0;
-}
-
-table.field-list p {
-    margin-bottom: 0.8em;
-}
-
-/* Cloned from
- * https://github.com/sphinx-doc/sphinx/commit/ef60dbfce09286b20b7385333d63a60321784e68
- */
-.field-name {
-    -moz-hyphens: manual;
-    -ms-hyphens: manual;
-    -webkit-hyphens: manual;
-    hyphens: manual;
-}
-
-table.footnote td.label {
-    width: .1px;
-    padding: 0.3em 0 0.3em 0.5em;
-}
-
-table.footnote td {
-    padding: 0.3em 0.5em;
-}
-
-dl {
-    margin-left: 0;
-    margin-right: 0;
-    margin-top: 0;
-    padding: 0;
-}
-
-dl dd {
-    margin-left: 30px;
-}
-
-blockquote {
-    margin: 0 0 0 30px;
-    padding: 0;
-}
-
-ul, ol {
-    /* Matches the 30px from the narrow-screen "li > ul" selector below */
-    margin: 10px 0 10px 30px;
-    padding: 0;
-}
-
-pre {
-    background: #EEE;
-    padding: 7px 30px;
-    margin: 15px 0px;
-    line-height: 1.3em;
-}
-
-div.viewcode-block:target {
-    background: #ffd;
-}
-
-dl pre, blockquote pre, li pre {
-    margin-left: 0;
-    padding-left: 30px;
-}
-
-tt, code {
-    background-color: #ecf0f3;
-    color: #222;
-    /* padding: 1px 2px; */
-}
-
-tt.xref, code.xref, a tt {
-    background-color: #FBFBFB;
-    border-bottom: 1px solid #fff;
-}
-
-a.reference {
-    text-decoration: none;
-    border-bottom: 1px dotted #004B6B;
-}
-
-/* Don't put an underline on images */
-a.image-reference, a.image-reference:hover {
-    border-bottom: none;
-}
-
-a.reference:hover {
-    border-bottom: 1px solid #6D4100;
-}
-
-a.footnote-reference {
-    text-decoration: none;
-    font-size: 0.7em;
-    vertical-align: top;
-    border-bottom: 1px dotted #004B6B;
-}
-
-a.footnote-reference:hover {
-    border-bottom: 1px solid #6D4100;
-}
-
-a:hover tt, a:hover code {
-    background: #EEE;
-}
-
-
-@media screen and (max-width: 870px) {
-
-    div.sphinxsidebar {
-    	display: none;
-    }
-
-    div.document {
-       width: 100%;
-
-    }
-
-    div.documentwrapper {
-    	margin-left: 0;
-    	margin-top: 0;
-    	margin-right: 0;
-    	margin-bottom: 0;
-    }
-
-    div.bodywrapper {
-    	margin-top: 0;
-    	margin-right: 0;
-    	margin-bottom: 0;
-    	margin-left: 0;
-    }
-
-    ul {
-    	margin-left: 0;
-    }
-
-	li > ul {
-        /* Matches the 30px from the "ul, ol" selector above */
-		margin-left: 30px;
-	}
-
-    .document {
-    	width: auto;
-    }
-
-    .footer {
-    	width: auto;
-    }
-
-    .bodywrapper {
-    	margin: 0;
-    }
-
-    .footer {
-    	width: auto;
-    }
-
-    .github {
-        display: none;
-    }
-
-
-
-}
-
-
-
-@media screen and (max-width: 875px) {
-
-    body {
-        margin: 0;
-        padding: 20px 30px;
-    }
-
-    div.documentwrapper {
-        float: none;
-        background: #fff;
-    }
-
-    div.sphinxsidebar {
-        display: block;
-        float: none;
-        width: 102.5%;
-        margin: 50px -30px -20px -30px;
-        padding: 10px 20px;
-        background: #333;
-        color: #FFF;
-    }
-
-    div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
-    div.sphinxsidebar h3 a {
-        color: #fff;
-    }
-
-    div.sphinxsidebar a {
-        color: #AAA;
-    }
-
-    div.sphinxsidebar p.logo {
-        display: none;
-    }
-
-    div.document {
-        width: 100%;
-        margin: 0;
-    }
-
-    div.footer {
-        display: none;
-    }
-
-    div.bodywrapper {
-        margin: 0;
-    }
-
-    div.body {
-        min-height: 0;
-        padding: 0;
-    }
-
-    .rtd_doc_footer {
-        display: none;
-    }
-
-    .document {
-        width: auto;
-    }
-
-    .footer {
-        width: auto;
-    }
-
-    .footer {
-        width: auto;
-    }
-
-    .github {
-        display: none;
-    }
-}
-
-
-/* misc. */
-
-.revsys-inline {
-    display: none!important;
-}
-
-/* Hide ugly table cell borders in ..bibliography:: directive output */
-table.docutils.citation, table.docutils.citation td, table.docutils.citation th {
-  border: none;
-  /* Below needed in some edge cases; if not applied, bottom shadows appear */
-  -moz-box-shadow: none;
-  -webkit-box-shadow: none;
-  box-shadow: none;
-}
-
-
-/* relbar */
-
-.related {
-    line-height: 30px;
-    width: 100%;
-    font-size: 0.9rem;
-}
-
-.related.top {
-    border-bottom: 1px solid #EEE;
-    margin-bottom: 20px;
-}
-
-.related.bottom {
-    border-top: 1px solid #EEE;
-}
-
-.related ul {
-    padding: 0;
-    margin: 0;
-    list-style: none;
-}
-
-.related li {
-    display: inline;
-}
-
-nav#rellinks {
-    float: right;
-}
-
-nav#rellinks li+li:before {
-    content: "|";
-}
-
-nav#breadcrumbs li+li:before {
-    content: "\00BB";
-}
-
-/* Hide certain items when printing */
-@media print {
-    div.related {
-        display: none;
-    }
-}

_build/html/_static/basic.css

@@ -1,925 +0,0 @@
-/*
- * basic.css
- * ~~~~~~~~~
- *
- * Sphinx stylesheet -- basic theme.
- *
- * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/* -- main layout ----------------------------------------------------------- */
-
-div.clearer {
-    clear: both;
-}
-
-div.section::after {
-    display: block;
-    content: '';
-    clear: left;
-}
-
-/* -- relbar ---------------------------------------------------------------- */
-
-div.related {
-    width: 100%;
-    font-size: 90%;
-}
-
-div.related h3 {
-    display: none;
-}
-
-div.related ul {
-    margin: 0;
-    padding: 0 0 0 10px;
-    list-style: none;
-}
-
-div.related li {
-    display: inline;
-}
-
-div.related li.right {
-    float: right;
-    margin-right: 5px;
-}
-
-/* -- sidebar --------------------------------------------------------------- */
-
-div.sphinxsidebarwrapper {
-    padding: 10px 5px 0 10px;
-}
-
-div.sphinxsidebar {
-    float: left;
-    width: 230px;
-    margin-left: -100%;
-    font-size: 90%;
-    word-wrap: break-word;
-    overflow-wrap : break-word;
-}
-
-div.sphinxsidebar ul {
-    list-style: none;
-}
-
-div.sphinxsidebar ul ul,
-div.sphinxsidebar ul.want-points {
-    margin-left: 20px;
-    list-style: square;
-}
-
-div.sphinxsidebar ul ul {
-    margin-top: 0;
-    margin-bottom: 0;
-}
-
-div.sphinxsidebar form {
-    margin-top: 10px;
-}
-
-div.sphinxsidebar input {
-    border: 1px solid #98dbcc;
-    font-family: sans-serif;
-    font-size: 1em;
-}
-
-div.sphinxsidebar #searchbox form.search {
-    overflow: hidden;
-}
-
-div.sphinxsidebar #searchbox input[type="text"] {
-    float: left;
-    width: 80%;
-    padding: 0.25em;
-    box-sizing: border-box;
-}
-
-div.sphinxsidebar #searchbox input[type="submit"] {
-    float: left;
-    width: 20%;
-    border-left: none;
-    padding: 0.25em;
-    box-sizing: border-box;
-}
-
-
-img {
-    border: 0;
-    max-width: 100%;
-}
-
-/* -- search page ----------------------------------------------------------- */
-
-ul.search {
-    margin: 10px 0 0 20px;
-    padding: 0;
-}
-
-ul.search li {
-    padding: 5px 0 5px 20px;
-    background-image: url(file.png);
-    background-repeat: no-repeat;
-    background-position: 0 7px;
-}
-
-ul.search li a {
-    font-weight: bold;
-}
-
-ul.search li p.context {
-    color: #888;
-    margin: 2px 0 0 30px;
-    text-align: left;
-}
-
-ul.keywordmatches li.goodmatch a {
-    font-weight: bold;
-}
-
-/* -- index page ------------------------------------------------------------ */
-
-table.contentstable {
-    width: 90%;
-    margin-left: auto;
-    margin-right: auto;
-}
-
-table.contentstable p.biglink {
-    line-height: 150%;
-}
-
-a.biglink {
-    font-size: 1.3em;
-}
-
-span.linkdescr {
-    font-style: italic;
-    padding-top: 5px;
-    font-size: 90%;
-}
-
-/* -- general index --------------------------------------------------------- */
-
-table.indextable {
-    width: 100%;
-}
-
-table.indextable td {
-    text-align: left;
-    vertical-align: top;
-}
-
-table.indextable ul {
-    margin-top: 0;
-    margin-bottom: 0;
-    list-style-type: none;
-}
-
-table.indextable > tbody > tr > td > ul {
-    padding-left: 0em;
-}
-
-table.indextable tr.pcap {
-    height: 10px;
-}
-
-table.indextable tr.cap {
-    margin-top: 10px;
-    background-color: #f2f2f2;
-}
-
-img.toggler {
-    margin-right: 3px;
-    margin-top: 3px;
-    cursor: pointer;
-}
-
-div.modindex-jumpbox {
-    border-top: 1px solid #ddd;
-    border-bottom: 1px solid #ddd;
-    margin: 1em 0 1em 0;
-    padding: 0.4em;
-}
-
-div.genindex-jumpbox {
-    border-top: 1px solid #ddd;
-    border-bottom: 1px solid #ddd;
-    margin: 1em 0 1em 0;
-    padding: 0.4em;
-}
-
-/* -- domain module index --------------------------------------------------- */
-
-table.modindextable td {
-    padding: 2px;
-    border-collapse: collapse;
-}
-
-/* -- general body styles --------------------------------------------------- */
-
-div.body {
-    min-width: inherit;
-    max-width: 800px;
-}
-
-div.body p, div.body dd, div.body li, div.body blockquote {
-    -moz-hyphens: auto;
-    -ms-hyphens: auto;
-    -webkit-hyphens: auto;
-    hyphens: auto;
-}
-
-a.headerlink {
-    visibility: hidden;
-}
-
-a:visited {
-    color: #551A8B;
-}
-
-h1:hover > a.headerlink,
-h2:hover > a.headerlink,
-h3:hover > a.headerlink,
-h4:hover > a.headerlink,
-h5:hover > a.headerlink,
-h6:hover > a.headerlink,
-dt:hover > a.headerlink,
-caption:hover > a.headerlink,
-p.caption:hover > a.headerlink,
-div.code-block-caption:hover > a.headerlink {
-    visibility: visible;
-}
-
-div.body p.caption {
-    text-align: inherit;
-}
-
-div.body td {
-    text-align: left;
-}
-
-.first {
-    margin-top: 0 !important;
-}
-
-p.rubric {
-    margin-top: 30px;
-    font-weight: bold;
-}
-
-img.align-left, figure.align-left, .figure.align-left, object.align-left {
-    clear: left;
-    float: left;
-    margin-right: 1em;
-}
-
-img.align-right, figure.align-right, .figure.align-right, object.align-right {
-    clear: right;
-    float: right;
-    margin-left: 1em;
-}
-
-img.align-center, figure.align-center, .figure.align-center, object.align-center {
-  display: block;
-  margin-left: auto;
-  margin-right: auto;
-}
-
-img.align-default, figure.align-default, .figure.align-default {
-  display: block;
-  margin-left: auto;
-  margin-right: auto;
-}
-
-.align-left {
-    text-align: left;
-}
-
-.align-center {
-    text-align: center;
-}
-
-.align-default {
-    text-align: center;
-}
-
-.align-right {
-    text-align: right;
-}
-
-/* -- sidebars -------------------------------------------------------------- */
-
-div.sidebar,
-aside.sidebar {
-    margin: 0 0 0.5em 1em;
-    border: 1px solid #ddb;
-    padding: 7px;
-    background-color: #ffe;
-    width: 40%;
-    float: right;
-    clear: right;
-    overflow-x: auto;
-}
-
-p.sidebar-title {
-    font-weight: bold;
-}
-
-nav.contents,
-aside.topic,
-div.admonition, div.topic, blockquote {
-    clear: left;
-}
-
-/* -- topics ---------------------------------------------------------------- */
-
-nav.contents,
-aside.topic,
-div.topic {
-    border: 1px solid #ccc;
-    padding: 7px;
-    margin: 10px 0 10px 0;
-}
-
-p.topic-title {
-    font-size: 1.1em;
-    font-weight: bold;
-    margin-top: 10px;
-}
-
-/* -- admonitions ----------------------------------------------------------- */
-
-div.admonition {
-    margin-top: 10px;
-    margin-bottom: 10px;
-    padding: 7px;
-}
-
-div.admonition dt {
-    font-weight: bold;
-}
-
-p.admonition-title {
-    margin: 0px 10px 5px 0px;
-    font-weight: bold;
-}
-
-div.body p.centered {
-    text-align: center;
-    margin-top: 25px;
-}
-
-/* -- content of sidebars/topics/admonitions -------------------------------- */
-
-div.sidebar > :last-child,
-aside.sidebar > :last-child,
-nav.contents > :last-child,
-aside.topic > :last-child,
-div.topic > :last-child,
-div.admonition > :last-child {
-    margin-bottom: 0;
-}
-
-div.sidebar::after,
-aside.sidebar::after,
-nav.contents::after,
-aside.topic::after,
-div.topic::after,
-div.admonition::after,
-blockquote::after {
-    display: block;
-    content: '';
-    clear: both;
-}
-
-/* -- tables ---------------------------------------------------------------- */
-
-table.docutils {
-    margin-top: 10px;
-    margin-bottom: 10px;
-    border: 0;
-    border-collapse: collapse;
-}
-
-table.align-center {
-    margin-left: auto;
-    margin-right: auto;
-}
-
-table.align-default {
-    margin-left: auto;
-    margin-right: auto;
-}
-
-table caption span.caption-number {
-    font-style: italic;
-}
-
-table caption span.caption-text {
-}
-
-table.docutils td, table.docutils th {
-    padding: 1px 8px 1px 5px;
-    border-top: 0;
-    border-left: 0;
-    border-right: 0;
-    border-bottom: 1px solid #aaa;
-}
-
-th {
-    text-align: left;
-    padding-right: 5px;
-}
-
-table.citation {
-    border-left: solid 1px gray;
-    margin-left: 1px;
-}
-
-table.citation td {
-    border-bottom: none;
-}
-
-th > :first-child,
-td > :first-child {
-    margin-top: 0px;
-}
-
-th > :last-child,
-td > :last-child {
-    margin-bottom: 0px;
-}
-
-/* -- figures --------------------------------------------------------------- */
-
-div.figure, figure {
-    margin: 0.5em;
-    padding: 0.5em;
-}
-
-div.figure p.caption, figcaption {
-    padding: 0.3em;
-}
-
-div.figure p.caption span.caption-number,
-figcaption span.caption-number {
-    font-style: italic;
-}
-
-div.figure p.caption span.caption-text,
-figcaption span.caption-text {
-}
-
-/* -- field list styles ----------------------------------------------------- */
-
-table.field-list td, table.field-list th {
-    border: 0 !important;
-}
-
-.field-list ul {
-    margin: 0;
-    padding-left: 1em;
-}
-
-.field-list p {
-    margin: 0;
-}
-
-.field-name {
-    -moz-hyphens: manual;
-    -ms-hyphens: manual;
-    -webkit-hyphens: manual;
-    hyphens: manual;
-}
-
-/* -- hlist styles ---------------------------------------------------------- */
-
-table.hlist {
-    margin: 1em 0;
-}
-
-table.hlist td {
-    vertical-align: top;
-}
-
-/* -- object description styles --------------------------------------------- */
-
-.sig {
-	font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-}
-
-.sig-name, code.descname {
-    background-color: transparent;
-    font-weight: bold;
-}
-
-.sig-name {
-	font-size: 1.1em;
-}
-
-code.descname {
-    font-size: 1.2em;
-}
-
-.sig-prename, code.descclassname {
-    background-color: transparent;
-}
-
-.optional {
-    font-size: 1.3em;
-}
-
-.sig-paren {
-    font-size: larger;
-}
-
-.sig-param.n {
-	font-style: italic;
-}
-
-/* C++ specific styling */
-
-.sig-inline.c-texpr,
-.sig-inline.cpp-texpr {
-	font-family: unset;
-}
-
-.sig.c   .k, .sig.c   .kt,
-.sig.cpp .k, .sig.cpp .kt {
-	color: #0033B3;
-}
-
-.sig.c   .m,
-.sig.cpp .m {
-	color: #1750EB;
-}
-
-.sig.c   .s, .sig.c   .sc,
-.sig.cpp .s, .sig.cpp .sc {
-	color: #067D17;
-}
-
-
-/* -- other body styles ----------------------------------------------------- */
-
-ol.arabic {
-    list-style: decimal;
-}
-
-ol.loweralpha {
-    list-style: lower-alpha;
-}
-
-ol.upperalpha {
-    list-style: upper-alpha;
-}
-
-ol.lowerroman {
-    list-style: lower-roman;
-}
-
-ol.upperroman {
-    list-style: upper-roman;
-}
-
-:not(li) > ol > li:first-child > :first-child,
-:not(li) > ul > li:first-child > :first-child {
-    margin-top: 0px;
-}
-
-:not(li) > ol > li:last-child > :last-child,
-:not(li) > ul > li:last-child > :last-child {
-    margin-bottom: 0px;
-}
-
-ol.simple ol p,
-ol.simple ul p,
-ul.simple ol p,
-ul.simple ul p {
-    margin-top: 0;
-}
-
-ol.simple > li:not(:first-child) > p,
-ul.simple > li:not(:first-child) > p {
-    margin-top: 0;
-}
-
-ol.simple p,
-ul.simple p {
-    margin-bottom: 0;
-}
-
-aside.footnote > span,
-div.citation > span {
-    float: left;
-}
-aside.footnote > span:last-of-type,
-div.citation > span:last-of-type {
-  padding-right: 0.5em;
-}
-aside.footnote > p {
-  margin-left: 2em;
-}
-div.citation > p {
-  margin-left: 4em;
-}
-aside.footnote > p:last-of-type,
-div.citation > p:last-of-type {
-    margin-bottom: 0em;
-}
-aside.footnote > p:last-of-type:after,
-div.citation > p:last-of-type:after {
-    content: "";
-    clear: both;
-}
-
-dl.field-list {
-    display: grid;
-    grid-template-columns: fit-content(30%) auto;
-}
-
-dl.field-list > dt {
-    font-weight: bold;
-    word-break: break-word;
-    padding-left: 0.5em;
-    padding-right: 5px;
-}
-
-dl.field-list > dd {
-    padding-left: 0.5em;
-    margin-top: 0em;
-    margin-left: 0em;
-    margin-bottom: 0em;
-}
-
-dl {
-    margin-bottom: 15px;
-}
-
-dd > :first-child {
-    margin-top: 0px;
-}
-
-dd ul, dd table {
-    margin-bottom: 10px;
-}
-
-dd {
-    margin-top: 3px;
-    margin-bottom: 10px;
-    margin-left: 30px;
-}
-
-.sig dd {
-    margin-top: 0px;
-    margin-bottom: 0px;
-}
-
-.sig dl {
-    margin-top: 0px;
-    margin-bottom: 0px;
-}
-
-dl > dd:last-child,
-dl > dd:last-child > :last-child {
-    margin-bottom: 0;
-}
-
-dt:target, span.highlighted {
-    background-color: #fbe54e;
-}
-
-rect.highlighted {
-    fill: #fbe54e;
-}
-
-dl.glossary dt {
-    font-weight: bold;
-    font-size: 1.1em;
-}
-
-.versionmodified {
-    font-style: italic;
-}
-
-.system-message {
-    background-color: #fda;
-    padding: 5px;
-    border: 3px solid red;
-}
-
-.footnote:target  {
-    background-color: #ffa;
-}
-
-.line-block {
-    display: block;
-    margin-top: 1em;
-    margin-bottom: 1em;
-}
-
-.line-block .line-block {
-    margin-top: 0;
-    margin-bottom: 0;
-    margin-left: 1.5em;
-}
-
-.guilabel, .menuselection {
-    font-family: sans-serif;
-}
-
-.accelerator {
-    text-decoration: underline;
-}
-
-.classifier {
-    font-style: oblique;
-}
-
-.classifier:before {
-    font-style: normal;
-    margin: 0 0.5em;
-    content: ":";
-    display: inline-block;
-}
-
-abbr, acronym {
-    border-bottom: dotted 1px;
-    cursor: help;
-}
-
-.translated {
-    background-color: rgba(207, 255, 207, 0.2)
-}
-
-.untranslated {
-    background-color: rgba(255, 207, 207, 0.2)
-}
-
-/* -- code displays --------------------------------------------------------- */
-
-pre {
-    overflow: auto;
-    overflow-y: hidden;  /* fixes display issues on Chrome browsers */
-}
-
-pre, div[class*="highlight-"] {
-    clear: both;
-}
-
-span.pre {
-    -moz-hyphens: none;
-    -ms-hyphens: none;
-    -webkit-hyphens: none;
-    hyphens: none;
-    white-space: nowrap;
-}
-
-div[class*="highlight-"] {
-    margin: 1em 0;
-}
-
-td.linenos pre {
-    border: 0;
-    background-color: transparent;
-    color: #aaa;
-}
-
-table.highlighttable {
-    display: block;
-}
-
-table.highlighttable tbody {
-    display: block;
-}
-
-table.highlighttable tr {
-    display: flex;
-}
-
-table.highlighttable td {
-    margin: 0;
-    padding: 0;
-}
-
-table.highlighttable td.linenos {
-    padding-right: 0.5em;
-}
-
-table.highlighttable td.code {
-    flex: 1;
-    overflow: hidden;
-}
-
-.highlight .hll {
-    display: block;
-}
-
-div.highlight pre,
-table.highlighttable pre {
-    margin: 0;
-}
-
-div.code-block-caption + div {
-    margin-top: 0;
-}
-
-div.code-block-caption {
-    margin-top: 1em;
-    padding: 2px 5px;
-    font-size: small;
-}
-
-div.code-block-caption code {
-    background-color: transparent;
-}
-
-table.highlighttable td.linenos,
-span.linenos,
-div.highlight span.gp {  /* gp: Generic.Prompt */
-  user-select: none;
-  -webkit-user-select: text; /* Safari fallback only */
-  -webkit-user-select: none; /* Chrome/Safari */
-  -moz-user-select: none; /* Firefox */
-  -ms-user-select: none; /* IE10+ */
-}
-
-div.code-block-caption span.caption-number {
-    padding: 0.1em 0.3em;
-    font-style: italic;
-}
-
-div.code-block-caption span.caption-text {
-}
-
-div.literal-block-wrapper {
-    margin: 1em 0;
-}
-
-code.xref, a code {
-    background-color: transparent;
-    font-weight: bold;
-}
-
-h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
-    background-color: transparent;
-}
-
-.viewcode-link {
-    float: right;
-}
-
-.viewcode-back {
-    float: right;
-    font-family: sans-serif;
-}
-
-div.viewcode-block:target {
-    margin: -1px -10px;
-    padding: 0 10px;
-}
-
-/* -- math display ---------------------------------------------------------- */
-
-img.math {
-    vertical-align: middle;
-}
-
-div.body div.math p {
-    text-align: center;
-}
-
-span.eqno {
-    float: right;
-}
-
-span.eqno a.headerlink {
-    position: absolute;
-    z-index: 1;
-}
-
-div.math:hover a.headerlink {
-    visibility: visible;
-}
-
-/* -- printout stylesheet --------------------------------------------------- */
-
-@media print {
-    div.document,
-    div.documentwrapper,
-    div.bodywrapper {
-        margin: 0 !important;
-        width: 100%;
-    }
-
-    div.sphinxsidebar,
-    div.related,
-    div.footer,
-    #top-link {
-        display: none;
-    }
-}

_build/html/_static/custom.css

@@ -1 +0,0 @@
-/* This file intentionally left blank. */

_build/html/_static/doctools.js

@@ -1,156 +0,0 @@
-/*
- * doctools.js
- * ~~~~~~~~~~~
- *
- * Base JavaScript utilities for all Sphinx HTML documentation.
- *
- * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-"use strict";
-
-const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([
-  "TEXTAREA",
-  "INPUT",
-  "SELECT",
-  "BUTTON",
-]);
-
-const _ready = (callback) => {
-  if (document.readyState !== "loading") {
-    callback();
-  } else {
-    document.addEventListener("DOMContentLoaded", callback);
-  }
-};
-
-/**
- * Small JavaScript module for the documentation.
- */
-const Documentation = {
-  init: () => {
-    Documentation.initDomainIndexTable();
-    Documentation.initOnKeyListeners();
-  },
-
-  /**
-   * i18n support
-   */
-  TRANSLATIONS: {},
-  PLURAL_EXPR: (n) => (n === 1 ? 0 : 1),
-  LOCALE: "unknown",
-
-  // gettext and ngettext don't access this so that the functions
-  // can safely bound to a different name (_ = Documentation.gettext)
-  gettext: (string) => {
-    const translated = Documentation.TRANSLATIONS[string];
-    switch (typeof translated) {
-      case "undefined":
-        return string; // no translation
-      case "string":
-        return translated; // translation exists
-      default:
-        return translated[0]; // (singular, plural) translation tuple exists
-    }
-  },
-
-  ngettext: (singular, plural, n) => {
-    const translated = Documentation.TRANSLATIONS[singular];
-    if (typeof translated !== "undefined")
-      return translated[Documentation.PLURAL_EXPR(n)];
-    return n === 1 ? singular : plural;
-  },
-
-  addTranslations: (catalog) => {
-    Object.assign(Documentation.TRANSLATIONS, catalog.messages);
-    Documentation.PLURAL_EXPR = new Function(
-      "n",
-      `return (${catalog.plural_expr})`
-    );
-    Documentation.LOCALE = catalog.locale;
-  },
-
-  /**
-   * helper function to focus on search bar
-   */
-  focusSearchBar: () => {
-    document.querySelectorAll("input[name=q]")[0]?.focus();
-  },
-
-  /**
-   * Initialise the domain index toggle buttons
-   */
-  initDomainIndexTable: () => {
-    const toggler = (el) => {
-      const idNumber = el.id.substr(7);
-      const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`);
-      if (el.src.substr(-9) === "minus.png") {
-        el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`;
-        toggledRows.forEach((el) => (el.style.display = "none"));
-      } else {
-        el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`;
-        toggledRows.forEach((el) => (el.style.display = ""));
-      }
-    };
-
-    const togglerElements = document.querySelectorAll("img.toggler");
-    togglerElements.forEach((el) =>
-      el.addEventListener("click", (event) => toggler(event.currentTarget))
-    );
-    togglerElements.forEach((el) => (el.style.display = ""));
-    if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler);
-  },
-
-  initOnKeyListeners: () => {
-    // only install a listener if it is really needed
-    if (
-      !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS &&
-      !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS
-    )
-      return;
-
-    document.addEventListener("keydown", (event) => {
-      // bail for input elements
-      if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
-      // bail with special keys
-      if (event.altKey || event.ctrlKey || event.metaKey) return;
-
-      if (!event.shiftKey) {
-        switch (event.key) {
-          case "ArrowLeft":
-            if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
-
-            const prevLink = document.querySelector('link[rel="prev"]');
-            if (prevLink && prevLink.href) {
-              window.location.href = prevLink.href;
-              event.preventDefault();
-            }
-            break;
-          case "ArrowRight":
-            if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
-
-            const nextLink = document.querySelector('link[rel="next"]');
-            if (nextLink && nextLink.href) {
-              window.location.href = nextLink.href;
-              event.preventDefault();
-            }
-            break;
-        }
-      }
-
-      // some keyboard layouts may need Shift to get /
-      switch (event.key) {
-        case "/":
-          if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break;
-          Documentation.focusSearchBar();
-          event.preventDefault();
-      }
-    });
-  },
-};
-
-// quick alias for translations
-const _ = Documentation.gettext;
-
-_ready(Documentation.init);

_build/html/_static/documentation_options.js

@@ -1,13 +0,0 @@
-const DOCUMENTATION_OPTIONS = {
-    VERSION: '0.0.21',
-    LANGUAGE: 'en',
-    COLLAPSE_INDEX: false,
-    BUILDER: 'html',
-    FILE_SUFFIX: '.html',
-    LINK_SUFFIX: '.html',
-    HAS_SOURCE: true,
-    SOURCELINK_SUFFIX: '.txt',
-    NAVIGATION_WITH_KEYS: false,
-    SHOW_SEARCH_SUMMARY: true,
-    ENABLE_SEARCH_SHORTCUTS: true,
-};

_build/html/_static/jquery.js

@@ -1,2 +0,0 @@
-/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */
-!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),j=function(e,t){return e===t&&(l=!0),0},D={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^Line truncated

_build/html/_static/language_data.js

@@ -1,199 +0,0 @@
-/*
- * language_data.js
- * ~~~~~~~~~~~~~~~~
- *
- * This script contains the language-specific data used by searchtools.js,
- * namely the list of stopwords, stemmer, scorer and splitter.
- *
- * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"];
-
-
-/* Non-minified version is copied as a separate JS file, if available */
-
-/**
- * Porter Stemmer
- */
-var Stemmer = function() {
-
-  var step2list = {
-    ational: 'ate',
-    tional: 'tion',
-    enci: 'ence',
-    anci: 'ance',
-    izer: 'ize',
-    bli: 'ble',
-    alli: 'al',
-    entli: 'ent',
-    eli: 'e',
-    ousli: 'ous',
-    ization: 'ize',
-    ation: 'ate',
-    ator: 'ate',
-    alism: 'al',
-    iveness: 'ive',
-    fulness: 'ful',
-    ousness: 'ous',
-    aliti: 'al',
-    iviti: 'ive',
-    biliti: 'ble',
-    logi: 'log'
-  };
-
-  var step3list = {
-    icate: 'ic',
-    ative: '',
-    alize: 'al',
-    iciti: 'ic',
-    ical: 'ic',
-    ful: '',
-    ness: ''
-  };
-
-  var c = "[^aeiou]";          // consonant
-  var v = "[aeiouy]";          // vowel
-  var C = c + "[^aeiouy]*";    // consonant sequence
-  var V = v + "[aeiou]*";      // vowel sequence
-
-  var mgr0 = "^(" + C + ")?" + V + C;                      // [C]VC... is m>0
-  var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$";    // [C]VC[V] is m=1
-  var mgr1 = "^(" + C + ")?" + V + C + V + C;              // [C]VCVC... is m>1
-  var s_v   = "^(" + C + ")?" + v;                         // vowel in stem
-
-  this.stemWord = function (w) {
-    var stem;
-    var suffix;
-    var firstch;
-    var origword = w;
-
-    if (w.length < 3)
-      return w;
-
-    var re;
-    var re2;
-    var re3;
-    var re4;
-
-    firstch = w.substr(0,1);
-    if (firstch == "y")
-      w = firstch.toUpperCase() + w.substr(1);
-
-    // Step 1a
-    re = /^(.+?)(ss|i)es$/;
-    re2 = /^(.+?)([^s])s$/;
-
-    if (re.test(w))
-      w = w.replace(re,"$1$2");
-    else if (re2.test(w))
-      w = w.replace(re2,"$1$2");
-
-    // Step 1b
-    re = /^(.+?)eed$/;
-    re2 = /^(.+?)(ed|ing)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      re = new RegExp(mgr0);
-      if (re.test(fp[1])) {
-        re = /.$/;
-        w = w.replace(re,"");
-      }
-    }
-    else if (re2.test(w)) {
-      var fp = re2.exec(w);
-      stem = fp[1];
-      re2 = new RegExp(s_v);
-      if (re2.test(stem)) {
-        w = stem;
-        re2 = /(at|bl|iz)$/;
-        re3 = new RegExp("([^aeiouylsz])\\1$");
-        re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
-        if (re2.test(w))
-          w = w + "e";
-        else if (re3.test(w)) {
-          re = /.$/;
-          w = w.replace(re,"");
-        }
-        else if (re4.test(w))
-          w = w + "e";
-      }
-    }
-
-    // Step 1c
-    re = /^(.+?)y$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      re = new RegExp(s_v);
-      if (re.test(stem))
-        w = stem + "i";
-    }
-
-    // Step 2
-    re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      suffix = fp[2];
-      re = new RegExp(mgr0);
-      if (re.test(stem))
-        w = stem + step2list[suffix];
-    }
-
-    // Step 3
-    re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      suffix = fp[2];
-      re = new RegExp(mgr0);
-      if (re.test(stem))
-        w = stem + step3list[suffix];
-    }
-
-    // Step 4
-    re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
-    re2 = /^(.+?)(s|t)(ion)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      re = new RegExp(mgr1);
-      if (re.test(stem))
-        w = stem;
-    }
-    else if (re2.test(w)) {
-      var fp = re2.exec(w);
-      stem = fp[1] + fp[2];
-      re2 = new RegExp(mgr1);
-      if (re2.test(stem))
-        w = stem;
-    }
-
-    // Step 5
-    re = /^(.+?)e$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      re = new RegExp(mgr1);
-      re2 = new RegExp(meq1);
-      re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
-      if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
-        w = stem;
-    }
-    re = /ll$/;
-    re2 = new RegExp(mgr1);
-    if (re.test(w) && re2.test(w)) {
-      re = /.$/;
-      w = w.replace(re,"");
-    }
-
-    // and turn initial Y back to y
-    if (firstch == "y")
-      w = firstch.toLowerCase() + w.substr(1);
-    return w;
-  }
-}
-

_build/html/_static/pygments.css

@@ -1,84 +0,0 @@
-pre { line-height: 125%; }
-td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
-span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
-td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
-span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
-.highlight .hll { background-color: #ffffcc }
-.highlight { background: #f8f8f8; }
-.highlight .c { color: #8f5902; font-style: italic } /* Comment */
-.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
-.highlight .g { color: #000000 } /* Generic */
-.highlight .k { color: #004461; font-weight: bold } /* Keyword */
-.highlight .l { color: #000000 } /* Literal */
-.highlight .n { color: #000000 } /* Name */
-.highlight .o { color: #582800 } /* Operator */
-.highlight .x { color: #000000 } /* Other */
-.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
-.highlight .ch { color: #8f5902; font-style: italic } /* Comment.Hashbang */
-.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #8f5902 } /* Comment.Preproc */
-.highlight .cpf { color: #8f5902; font-style: italic } /* Comment.PreprocFile */
-.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
-.highlight .gd { color: #a40000 } /* Generic.Deleted */
-.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
-.highlight .ges { color: #000000 } /* Generic.EmphStrong */
-.highlight .gr { color: #ef2929 } /* Generic.Error */
-.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.highlight .gi { color: #00A000 } /* Generic.Inserted */
-.highlight .go { color: #888888 } /* Generic.Output */
-.highlight .gp { color: #745334 } /* Generic.Prompt */
-.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
-.highlight .kc { color: #004461; font-weight: bold } /* Keyword.Constant */
-.highlight .kd { color: #004461; font-weight: bold } /* Keyword.Declaration */
-.highlight .kn { color: #004461; font-weight: bold } /* Keyword.Namespace */
-.highlight .kp { color: #004461; font-weight: bold } /* Keyword.Pseudo */
-.highlight .kr { color: #004461; font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: #004461; font-weight: bold } /* Keyword.Type */
-.highlight .ld { color: #000000 } /* Literal.Date */
-.highlight .m { color: #990000 } /* Literal.Number */
-.highlight .s { color: #4e9a06 } /* Literal.String */
-.highlight .na { color: #c4a000 } /* Name.Attribute */
-.highlight .nb { color: #004461 } /* Name.Builtin */
-.highlight .nc { color: #000000 } /* Name.Class */
-.highlight .no { color: #000000 } /* Name.Constant */
-.highlight .nd { color: #888888 } /* Name.Decorator */
-.highlight .ni { color: #ce5c00 } /* Name.Entity */
-.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #000000 } /* Name.Function */
-.highlight .nl { color: #f57900 } /* Name.Label */
-.highlight .nn { color: #000000 } /* Name.Namespace */
-.highlight .nx { color: #000000 } /* Name.Other */
-.highlight .py { color: #000000 } /* Name.Property */
-.highlight .nt { color: #004461; font-weight: bold } /* Name.Tag */
-.highlight .nv { color: #000000 } /* Name.Variable */
-.highlight .ow { color: #004461; font-weight: bold } /* Operator.Word */
-.highlight .pm { color: #000000; font-weight: bold } /* Punctuation.Marker */
-.highlight .w { color: #f8f8f8 } /* Text.Whitespace */
-.highlight .mb { color: #990000 } /* Literal.Number.Bin */
-.highlight .mf { color: #990000 } /* Literal.Number.Float */
-.highlight .mh { color: #990000 } /* Literal.Number.Hex */
-.highlight .mi { color: #990000 } /* Literal.Number.Integer */
-.highlight .mo { color: #990000 } /* Literal.Number.Oct */
-.highlight .sa { color: #4e9a06 } /* Literal.String.Affix */
-.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
-.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
-.highlight .dl { color: #4e9a06 } /* Literal.String.Delimiter */
-.highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
-.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
-.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
-.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
-.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
-.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
-.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
-.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
-.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
-.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
-.highlight .fm { color: #000000 } /* Name.Function.Magic */
-.highlight .vc { color: #000000 } /* Name.Variable.Class */
-.highlight .vg { color: #000000 } /* Name.Variable.Global */
-.highlight .vi { color: #000000 } /* Name.Variable.Instance */
-.highlight .vm { color: #000000 } /* Name.Variable.Magic */
-.highlight .il { color: #990000 } /* Literal.Number.Integer.Long */

_build/html/_static/searchtools.js

@@ -1,619 +0,0 @@
-/*
- * searchtools.js
- * ~~~~~~~~~~~~~~~~
- *
- * Sphinx JavaScript utilities for the full-text search.
- *
- * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-"use strict";
-
-/**
- * Simple result scoring code.
- */
-if (typeof Scorer === "undefined") {
-  var Scorer = {
-    // Implement the following function to further tweak the score for each result
-    // The function takes a result array [docname, title, anchor, descr, score, filename]
-    // and returns the new score.
-    /*
-    score: result => {
-      const [docname, title, anchor, descr, score, filename] = result
-      return score
-    },
-    */
-
-    // query matches the full name of an object
-    objNameMatch: 11,
-    // or matches in the last dotted part of the object name
-    objPartialMatch: 6,
-    // Additive scores depending on the priority of the object
-    objPrio: {
-      0: 15, // used to be importantResults
-      1: 5, // used to be objectResults
-      2: -5, // used to be unimportantResults
-    },
-    //  Used when the priority is not in the mapping.
-    objPrioDefault: 0,
-
-    // query found in title
-    title: 15,
-    partialTitle: 7,
-    // query found in terms
-    term: 5,
-    partialTerm: 2,
-  };
-}
-
-const _removeChildren = (element) => {
-  while (element && element.lastChild) element.removeChild(element.lastChild);
-};
-
-/**
- * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
- */
-const _escapeRegExp = (string) =>
-  string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
-
-const _displayItem = (item, searchTerms, highlightTerms) => {
-  const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
-  const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
-  const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
-  const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;
-  const contentRoot = document.documentElement.dataset.content_root;
-
-  const [docName, title, anchor, descr, score, _filename] = item;
-
-  let listItem = document.createElement("li");
-  let requestUrl;
-  let linkUrl;
-  if (docBuilder === "dirhtml") {
-    // dirhtml builder
-    let dirname = docName + "/";
-    if (dirname.match(/\/index\/$/))
-      dirname = dirname.substring(0, dirname.length - 6);
-    else if (dirname === "index/") dirname = "";
-    requestUrl = contentRoot + dirname;
-    linkUrl = requestUrl;
-  } else {
-    // normal html builders
-    requestUrl = contentRoot + docName + docFileSuffix;
-    linkUrl = docName + docLinkSuffix;
-  }
-  let linkEl = listItem.appendChild(document.createElement("a"));
-  linkEl.href = linkUrl + anchor;
-  linkEl.dataset.score = score;
-  linkEl.innerHTML = title;
-  if (descr) {
-    listItem.appendChild(document.createElement("span")).innerHTML =
-      " (" + descr + ")";
-    // highlight search terms in the description
-    if (SPHINX_HIGHLIGHT_ENABLED)  // set in sphinx_highlight.js
-      highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted"));
-  }
-  else if (showSearchSummary)
-    fetch(requestUrl)
-      .then((responseData) => responseData.text())
-      .then((data) => {
-        if (data)
-          listItem.appendChild(
-            Search.makeSearchSummary(data, searchTerms, anchor)
-          );
-        // highlight search terms in the summary
-        if (SPHINX_HIGHLIGHT_ENABLED)  // set in sphinx_highlight.js
-          highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted"));
-      });
-  Search.output.appendChild(listItem);
-};
-const _finishSearch = (resultCount) => {
-  Search.stopPulse();
-  Search.title.innerText = _("Search Results");
-  if (!resultCount)
-    Search.status.innerText = Documentation.gettext(
-      "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories."
-    );
-  else
-    Search.status.innerText = _(
-      "Search finished, found ${resultCount} page(s) matching the search query."
-    ).replace('${resultCount}', resultCount);
-};
-const _displayNextItem = (
-  results,
-  resultCount,
-  searchTerms,
-  highlightTerms,
-) => {
-  // results left, load the summary and display it
-  // this is intended to be dynamic (don't sub resultsCount)
-  if (results.length) {
-    _displayItem(results.pop(), searchTerms, highlightTerms);
-    setTimeout(
-      () => _displayNextItem(results, resultCount, searchTerms, highlightTerms),
-      5
-    );
-  }
-  // search finished, update title and status message
-  else _finishSearch(resultCount);
-};
-// Helper function used by query() to order search results.
-// Each input is an array of [docname, title, anchor, descr, score, filename].
-// Order the results by score (in opposite order of appearance, since the
-// `_displayNextItem` function uses pop() to retrieve items) and then alphabetically.
-const _orderResultsByScoreThenName = (a, b) => {
-  const leftScore = a[4];
-  const rightScore = b[4];
-  if (leftScore === rightScore) {
-    // same score: sort alphabetically
-    const leftTitle = a[1].toLowerCase();
-    const rightTitle = b[1].toLowerCase();
-    if (leftTitle === rightTitle) return 0;
-    return leftTitle > rightTitle ? -1 : 1; // inverted is intentional
-  }
-  return leftScore > rightScore ? 1 : -1;
-};
-
-/**
- * Default splitQuery function. Can be overridden in ``sphinx.search`` with a
- * custom function per language.
- *
- * The regular expression works by splitting the string on consecutive characters
- * that are not Unicode letters, numbers, underscores, or emoji characters.
- * This is the same as ``\W+`` in Python, preserving the surrogate pair area.
- */
-if (typeof splitQuery === "undefined") {
-  var splitQuery = (query) => query
-      .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu)
-      .filter(term => term)  // remove remaining empty strings
-}
-
-/**
- * Search Module
- */
-const Search = {
-  _index: null,
-  _queued_query: null,
-  _pulse_status: -1,
-
-  htmlToText: (htmlString, anchor) => {
-    const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html');
-    for (const removalQuery of [".headerlinks", "script", "style"]) {
-      htmlElement.querySelectorAll(removalQuery).forEach((el) => { el.remove() });
-    }
-    if (anchor) {
-      const anchorContent = htmlElement.querySelector(`[role="main"] ${anchor}`);
-      if (anchorContent) return anchorContent.textContent;
-
-      console.warn(
-        `Anchored content block not found. Sphinx search tries to obtain it via DOM query '[role=main] ${anchor}'. Check your theme or template.`
-      );
-    }
-
-    // if anchor not specified or not found, fall back to main content
-    const docContent = htmlElement.querySelector('[role="main"]');
-    if (docContent) return docContent.textContent;
-
-    console.warn(
-      "Content block not found. Sphinx search tries to obtain it via DOM query '[role=main]'. Check your theme or template."
-    );
-    return "";
-  },
-
-  init: () => {
-    const query = new URLSearchParams(window.location.search).get("q");
-    document
-      .querySelectorAll('input[name="q"]')
-      .forEach((el) => (el.value = query));
-    if (query) Search.performSearch(query);
-  },
-
-  loadIndex: (url) =>
-    (document.body.appendChild(document.createElement("script")).src = url),
-
-  setIndex: (index) => {
-    Search._index = index;
-    if (Search._queued_query !== null) {
-      const query = Search._queued_query;
-      Search._queued_query = null;
-      Search.query(query);
-    }
-  },
-
-  hasIndex: () => Search._index !== null,
-
-  deferQuery: (query) => (Search._queued_query = query),
-
-  stopPulse: () => (Search._pulse_status = -1),
-
-  startPulse: () => {
-    if (Search._pulse_status >= 0) return;
-
-    const pulse = () => {
-      Search._pulse_status = (Search._pulse_status + 1) % 4;
-      Search.dots.innerText = ".".repeat(Search._pulse_status);
-      if (Search._pulse_status >= 0) window.setTimeout(pulse, 500);
-    };
-    pulse();
-  },
-
-  /**
-   * perform a search for something (or wait until index is loaded)
-   */
-  performSearch: (query) => {
-    // create the required interface elements
-    const searchText = document.createElement("h2");
-    searchText.textContent = _("Searching");
-    const searchSummary = document.createElement("p");
-    searchSummary.classList.add("search-summary");
-    searchSummary.innerText = "";
-    const searchList = document.createElement("ul");
-    searchList.classList.add("search");
-
-    const out = document.getElementById("search-results");
-    Search.title = out.appendChild(searchText);
-    Search.dots = Search.title.appendChild(document.createElement("span"));
-    Search.status = out.appendChild(searchSummary);
-    Search.output = out.appendChild(searchList);
-
-    const searchProgress = document.getElementById("search-progress");
-    // Some themes don't use the search progress node
-    if (searchProgress) {
-      searchProgress.innerText = _("Preparing search...");
-    }
-    Search.startPulse();
-
-    // index already loaded, the browser was quick!
-    if (Search.hasIndex()) Search.query(query);
-    else Search.deferQuery(query);
-  },
-
-  _parseQuery: (query) => {
-    // stem the search terms and add them to the correct list
-    const stemmer = new Stemmer();
-    const searchTerms = new Set();
-    const excludedTerms = new Set();
-    const highlightTerms = new Set();
-    const objectTerms = new Set(splitQuery(query.toLowerCase().trim()));
-    splitQuery(query.trim()).forEach((queryTerm) => {
-      const queryTermLower = queryTerm.toLowerCase();
-
-      // maybe skip this "word"
-      // stopwords array is from language_data.js
-      if (
-        stopwords.indexOf(queryTermLower) !== -1 ||
-        queryTerm.match(/^\d+$/)
-      )
-        return;
-
-      // stem the word
-      let word = stemmer.stemWord(queryTermLower);
-      // select the correct list
-      if (word[0] === "-") excludedTerms.add(word.substr(1));
-      else {
-        searchTerms.add(word);
-        highlightTerms.add(queryTermLower);
-      }
-    });
-
-    if (SPHINX_HIGHLIGHT_ENABLED) {  // set in sphinx_highlight.js
-      localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" "))
-    }
-
-    // console.debug("SEARCH: searching for:");
-    // console.info("required: ", [...searchTerms]);
-    // console.info("excluded: ", [...excludedTerms]);
-
-    return [query, searchTerms, excludedTerms, highlightTerms, objectTerms];
-  },
-
-  /**
-   * execute search (requires search index to be loaded)
-   */
-  _performSearch: (query, searchTerms, excludedTerms, highlightTerms, objectTerms) => {
-    const filenames = Search._index.filenames;
-    const docNames = Search._index.docnames;
-    const titles = Search._index.titles;
-    const allTitles = Search._index.alltitles;
-    const indexEntries = Search._index.indexentries;
-
-    // Collect multiple result groups to be sorted separately and then ordered.
-    // Each is an array of [docname, title, anchor, descr, score, filename].
-    const normalResults = [];
-    const nonMainIndexResults = [];
-
-    _removeChildren(document.getElementById("search-progress"));
-
-    const queryLower = query.toLowerCase().trim();
-    for (const [title, foundTitles] of Object.entries(allTitles)) {
-      if (title.toLowerCase().trim().includes(queryLower) && (queryLower.length >= title.length/2)) {
-        for (const [file, id] of foundTitles) {
-          let score = Math.round(100 * queryLower.length / title.length)
-          normalResults.push([
-            docNames[file],
-            titles[file] !== title ? `${titles[file]} > ${title}` : title,
-            id !== null ? "#" + id : "",
-            null,
-            score,
-            filenames[file],
-          ]);
-        }
-      }
-    }
-
-    // search for explicit entries in index directives
-    for (const [entry, foundEntries] of Object.entries(indexEntries)) {
-      if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) {
-        for (const [file, id, isMain] of foundEntries) {
-          const score = Math.round(100 * queryLower.length / entry.length);
-          const result = [
-            docNames[file],
-            titles[file],
-            id ? "#" + id : "",
-            null,
-            score,
-            filenames[file],
-          ];
-          if (isMain) {
-            normalResults.push(result);
-          } else {
-            nonMainIndexResults.push(result);
-          }
-        }
-      }
-    }
-
-    // lookup as object
-    objectTerms.forEach((term) =>
-      normalResults.push(...Search.performObjectSearch(term, objectTerms))
-    );
-
-    // lookup as search terms in fulltext
-    normalResults.push(...Search.performTermsSearch(searchTerms, excludedTerms));
-
-    // let the scorer override scores with a custom scoring function
-    if (Scorer.score) {
-      normalResults.forEach((item) => (item[4] = Scorer.score(item)));
-      nonMainIndexResults.forEach((item) => (item[4] = Scorer.score(item)));
-    }
-
-    // Sort each group of results by score and then alphabetically by name.
-    normalResults.sort(_orderResultsByScoreThenName);
-    nonMainIndexResults.sort(_orderResultsByScoreThenName);
-
-    // Combine the result groups in (reverse) order.
-    // Non-main index entries are typically arbitrary cross-references,
-    // so display them after other results.
-    let results = [...nonMainIndexResults, ...normalResults];
-
-    // remove duplicate search results
-    // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept
-    let seen = new Set();
-    results = results.reverse().reduce((acc, result) => {
-      let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(',');
-      if (!seen.has(resultStr)) {
-        acc.push(result);
-        seen.add(resultStr);
-      }
-      return acc;
-    }, []);
-
-    return results.reverse();
-  },
-
-  query: (query) => {
-    const [searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms] = Search._parseQuery(query);
-    const results = Search._performSearch(searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms);
-
-    // for debugging
-    //Search.lastresults = results.slice();  // a copy
-    // console.info("search results:", Search.lastresults);
-
-    // print the results
-    _displayNextItem(results, results.length, searchTerms, highlightTerms);
-  },
-
-  /**
-   * search for object names
-   */
-  performObjectSearch: (object, objectTerms) => {
-    const filenames = Search._index.filenames;
-    const docNames = Search._index.docnames;
-    const objects = Search._index.objects;
-    const objNames = Search._index.objnames;
-    const titles = Search._index.titles;
-
-    const results = [];
-
-    const objectSearchCallback = (prefix, match) => {
-      const name = match[4]
-      const fullname = (prefix ? prefix + "." : "") + name;
-      const fullnameLower = fullname.toLowerCase();
-      if (fullnameLower.indexOf(object) < 0) return;
-
-      let score = 0;
-      const parts = fullnameLower.split(".");
-
-      // check for different match types: exact matches of full name or
-      // "last name" (i.e. last dotted part)
-      if (fullnameLower === object || parts.slice(-1)[0] === object)
-        score += Scorer.objNameMatch;
-      else if (parts.slice(-1)[0].indexOf(object) > -1)
-        score += Scorer.objPartialMatch; // matches in last name
-
-      const objName = objNames[match[1]][2];
-      const title = titles[match[0]];
-
-      // If more than one term searched for, we require other words to be
-      // found in the name/title/description
-      const otherTerms = new Set(objectTerms);
-      otherTerms.delete(object);
-      if (otherTerms.size > 0) {
-        const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase();
-        if (
-          [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0)
-        )
-          return;
-      }
-
-      let anchor = match[3];
-      if (anchor === "") anchor = fullname;
-      else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname;
-
-      const descr = objName + _(", in ") + title;
-
-      // add custom score for some objects according to scorer
-      if (Scorer.objPrio.hasOwnProperty(match[2]))
-        score += Scorer.objPrio[match[2]];
-      else score += Scorer.objPrioDefault;
-
-      results.push([
-        docNames[match[0]],
-        fullname,
-        "#" + anchor,
-        descr,
-        score,
-        filenames[match[0]],
-      ]);
-    };
-    Object.keys(objects).forEach((prefix) =>
-      objects[prefix].forEach((array) =>
-        objectSearchCallback(prefix, array)
-      )
-    );
-    return results;
-  },
-
-  /**
-   * search for full-text terms in the index
-   */
-  performTermsSearch: (searchTerms, excludedTerms) => {
-    // prepare search
-    const terms = Search._index.terms;
-    const titleTerms = Search._index.titleterms;
-    const filenames = Search._index.filenames;
-    const docNames = Search._index.docnames;
-    const titles = Search._index.titles;
-
-    const scoreMap = new Map();
-    const fileMap = new Map();
-
-    // perform the search on the required terms
-    searchTerms.forEach((word) => {
-      const files = [];
-      const arr = [
-        { files: terms[word], score: Scorer.term },
-        { files: titleTerms[word], score: Scorer.title },
-      ];
-      // add support for partial matches
-      if (word.length > 2) {
-        const escapedWord = _escapeRegExp(word);
-        if (!terms.hasOwnProperty(word)) {
-          Object.keys(terms).forEach((term) => {
-            if (term.match(escapedWord))
-              arr.push({ files: terms[term], score: Scorer.partialTerm });
-          });
-        }
-        if (!titleTerms.hasOwnProperty(word)) {
-          Object.keys(titleTerms).forEach((term) => {
-            if (term.match(escapedWord))
-              arr.push({ files: titleTerms[term], score: Scorer.partialTitle });
-          });
-        }
-      }
-
-      // no match but word was a required one
-      if (arr.every((record) => record.files === undefined)) return;
-
-      // found search word in contents
-      arr.forEach((record) => {
-        if (record.files === undefined) return;
-
-        let recordFiles = record.files;
-        if (recordFiles.length === undefined) recordFiles = [recordFiles];
-        files.push(...recordFiles);
-
-        // set score for the word in each file
-        recordFiles.forEach((file) => {
-          if (!scoreMap.has(file)) scoreMap.set(file, {});
-          scoreMap.get(file)[word] = record.score;
-        });
-      });
-
-      // create the mapping
-      files.forEach((file) => {
-        if (!fileMap.has(file)) fileMap.set(file, [word]);
-        else if (fileMap.get(file).indexOf(word) === -1) fileMap.get(file).push(word);
-      });
-    });
-
-    // now check if the files don't contain excluded terms
-    const results = [];
-    for (const [file, wordList] of fileMap) {
-      // check if all requirements are matched
-
-      // as search terms with length < 3 are discarded
-      const filteredTermCount = [...searchTerms].filter(
-        (term) => term.length > 2
-      ).length;
-      if (
-        wordList.length !== searchTerms.size &&
-        wordList.length !== filteredTermCount
-      )
-        continue;
-
-      // ensure that none of the excluded terms is in the search result
-      if (
-        [...excludedTerms].some(
-          (term) =>
-            terms[term] === file ||
-            titleTerms[term] === file ||
-            (terms[term] || []).includes(file) ||
-            (titleTerms[term] || []).includes(file)
-        )
-      )
-        break;
-
-      // select one (max) score for the file.
-      const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w]));
-      // add result to the result list
-      results.push([
-        docNames[file],
-        titles[file],
-        "",
-        null,
-        score,
-        filenames[file],
-      ]);
-    }
-    return results;
-  },
-
-  /**
-   * helper function to return a node containing the
-   * search summary for a given text. keywords is a list
-   * of stemmed words.
-   */
-  makeSearchSummary: (htmlText, keywords, anchor) => {
-    const text = Search.htmlToText(htmlText, anchor);
-    if (text === "") return null;
-
-    const textLower = text.toLowerCase();
-    const actualStartPosition = [...keywords]
-      .map((k) => textLower.indexOf(k.toLowerCase()))
-      .filter((i) => i > -1)
-      .slice(-1)[0];
-    const startWithContext = Math.max(actualStartPosition - 120, 0);
-
-    const top = startWithContext === 0 ? "" : "...";
-    const tail = startWithContext + 240 < text.length ? "..." : "";
-
-    let summary = document.createElement("p");
-    summary.classList.add("context");
-    summary.textContent = top + text.substr(startWithContext, 240).trim() + tail;
-
-    return summary;
-  },
-};
-
-_ready(Search.init);

_build/html/_static/sphinx_highlight.js

@@ -1,154 +0,0 @@
-/* Highlighting utilities for Sphinx HTML documentation. */
-"use strict";
-
-const SPHINX_HIGHLIGHT_ENABLED = true
-
-/**
- * highlight a given string on a node by wrapping it in
- * span elements with the given class name.
- */
-const _highlight = (node, addItems, text, className) => {
-  if (node.nodeType === Node.TEXT_NODE) {
-    const val = node.nodeValue;
-    const parent = node.parentNode;
-    const pos = val.toLowerCase().indexOf(text);
-    if (
-      pos >= 0 &&
-      !parent.classList.contains(className) &&
-      !parent.classList.contains("nohighlight")
-    ) {
-      let span;
-
-      const closestNode = parent.closest("body, svg, foreignObject");
-      const isInSVG = closestNode && closestNode.matches("svg");
-      if (isInSVG) {
-        span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
-      } else {
-        span = document.createElement("span");
-        span.classList.add(className);
-      }
-
-      span.appendChild(document.createTextNode(val.substr(pos, text.length)));
-      const rest = document.createTextNode(val.substr(pos + text.length));
-      parent.insertBefore(
-        span,
-        parent.insertBefore(
-          rest,
-          node.nextSibling
-        )
-      );
-      node.nodeValue = val.substr(0, pos);
-      /* There may be more occurrences of search term in this node. So call this
-       * function recursively on the remaining fragment.
-       */
-      _highlight(rest, addItems, text, className);
-
-      if (isInSVG) {
-        const rect = document.createElementNS(
-          "http://www.w3.org/2000/svg",
-          "rect"
-        );
-        const bbox = parent.getBBox();
-        rect.x.baseVal.value = bbox.x;
-        rect.y.baseVal.value = bbox.y;
-        rect.width.baseVal.value = bbox.width;
-        rect.height.baseVal.value = bbox.height;
-        rect.setAttribute("class", className);
-        addItems.push({ parent: parent, target: rect });
-      }
-    }
-  } else if (node.matches && !node.matches("button, select, textarea")) {
-    node.childNodes.forEach((el) => _highlight(el, addItems, text, className));
-  }
-};
-const _highlightText = (thisNode, text, className) => {
-  let addItems = [];
-  _highlight(thisNode, addItems, text, className);
-  addItems.forEach((obj) =>
-    obj.parent.insertAdjacentElement("beforebegin", obj.target)
-  );
-};
-
-/**
- * Small JavaScript module for the documentation.
- */
-const SphinxHighlight = {
-
-  /**
-   * highlight the search words provided in localstorage in the text
-   */
-  highlightSearchWords: () => {
-    if (!SPHINX_HIGHLIGHT_ENABLED) return;  // bail if no highlight
-
-    // get and clear terms from localstorage
-    const url = new URL(window.location);
-    const highlight =
-        localStorage.getItem("sphinx_highlight_terms")
-        || url.searchParams.get("highlight")
-        || "";
-    localStorage.removeItem("sphinx_highlight_terms")
-    url.searchParams.delete("highlight");
-    window.history.replaceState({}, "", url);
-
-    // get individual terms from highlight string
-    const terms = highlight.toLowerCase().split(/\s+/).filter(x => x);
-    if (terms.length === 0) return; // nothing to do
-
-    // There should never be more than one element matching "div.body"
-    const divBody = document.querySelectorAll("div.body");
-    const body = divBody.length ? divBody[0] : document.querySelector("body");
-    window.setTimeout(() => {
-      terms.forEach((term) => _highlightText(body, term, "highlighted"));
-    }, 10);
-
-    const searchBox = document.getElementById("searchbox");
-    if (searchBox === null) return;
-    searchBox.appendChild(
-      document
-        .createRange()
-        .createContextualFragment(
-          '<p class="highlight-link">' +
-            '<a href="javascript:SphinxHighlight.hideSearchWords()">' +
-            _("Hide Search Matches") +
-            "</a></p>"
-        )
-    );
-  },
-
-  /**
-   * helper function to hide the search marks again
-   */
-  hideSearchWords: () => {
-    document
-      .querySelectorAll("#searchbox .highlight-link")
-      .forEach((el) => el.remove());
-    document
-      .querySelectorAll("span.highlighted")
-      .forEach((el) => el.classList.remove("highlighted"));
-    localStorage.removeItem("sphinx_highlight_terms")
-  },
-
-  initEscapeListener: () => {
-    // only install a listener if it is really needed
-    if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return;
-
-    document.addEventListener("keydown", (event) => {
-      // bail for input elements
-      if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
-      // bail with special keys
-      if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return;
-      if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) {
-        SphinxHighlight.hideSearchWords();
-        event.preventDefault();
-      }
-    });
-  },
-};
-
-_ready(() => {
-  /* Do not call highlightSearchWords() when we are on the search page.
-   * It will highlight words from the *previous* search query.
-   */
-  if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords();
-  SphinxHighlight.initEscapeListener();
-});

_build/html/genindex.html

@@ -1,414 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="./">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Index &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="_static/alabaster.css?v=12dfc556" />
-    <script src="_static/jquery.js?v=5d32c60e"></script>
-    <script src="_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="_static/documentation_options.js?v=a11416ff"></script>
-    <script src="_static/doctools.js?v=9a2dae69"></script>
-    <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="#" />
-    <link rel="search" title="Search" href="search.html" />
-   
-  <link rel="stylesheet" href="_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-
-<h1 id="index">Index</h1>
-
-<div class="genindex-jumpbox">
- <a href="#A"><strong>A</strong></a>
- | <a href="#B"><strong>B</strong></a>
- | <a href="#C"><strong>C</strong></a>
- | <a href="#D"><strong>D</strong></a>
- | <a href="#E"><strong>E</strong></a>
- | <a href="#G"><strong>G</strong></a>
- | <a href="#I"><strong>I</strong></a>
- | <a href="#L"><strong>L</strong></a>
- | <a href="#M"><strong>M</strong></a>
- | <a href="#P"><strong>P</strong></a>
- | <a href="#R"><strong>R</strong></a>
- | <a href="#S"><strong>S</strong></a>
- | <a href="#T"><strong>T</strong></a>
- 
-</div>
-<h2 id="A">A</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.agents_generator.AgentsGenerator">AgentsGenerator (class in praisonai.agents_generator)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_CodeDocsSearchTool">autogen_CodeDocsSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_CSVSearchTool">autogen_CSVSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_DirectoryReadTool">autogen_DirectoryReadTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_DirectorySearchTool">autogen_DirectorySearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_DOCXSearchTool">autogen_DOCXSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_FileReadTool">autogen_FileReadTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_JSONSearchTool">autogen_JSONSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_MDXSearchTool">autogen_MDXSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_PDFSearchTool">autogen_PDFSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_RagTool">autogen_RagTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeElementFromWebsiteTool">autogen_ScrapeElementFromWebsiteTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeWebsiteTool">autogen_ScrapeWebsiteTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_TXTSearchTool">autogen_TXTSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_WebsiteSearchTool">autogen_WebsiteSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_XMLSearchTool">autogen_XMLSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeChannelSearchTool">autogen_YoutubeChannelSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeVideoSearchTool">autogen_YoutubeVideoSearchTool() (in module praisonai.inbuilt_tools.autogen_tools)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.AutoGenerator">AutoGenerator (class in praisonai.auto)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="B">B</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.backstory">backstory (praisonai.auto.RoleDetails attribute)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="C">C</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.deploy.CloudDeployer">CloudDeployer (class in praisonai.deploy)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.AutoGenerator.convert_and_save">convert_and_save() (praisonai.auto.AutoGenerator method)</a>
-</li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.deploy.CloudDeployer.create_api_file">create_api_file() (praisonai.deploy.CloudDeployer method)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.deploy.CloudDeployer.create_dockerfile">create_dockerfile() (praisonai.deploy.CloudDeployer method)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.cli.PraisonAI.create_gradio_interface">create_gradio_interface() (praisonai.cli.PraisonAI method)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="D">D</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.TaskDetails.description">description (praisonai.auto.TaskDetails attribute)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="E">E</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.TaskDetails.expected_output">expected_output (praisonai.auto.TaskDetails attribute)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="G">G</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.AutoGenerator.generate">generate() (praisonai.auto.AutoGenerator method)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.test.generate_crew_and_kickoff">generate_crew_and_kickoff() (in module praisonai.test)</a>
-
-      <ul>
-        <li><a href="source/praisonai.html#praisonai.agents_generator.AgentsGenerator.generate_crew_and_kickoff">(praisonai.agents_generator.AgentsGenerator method)</a>
-</li>
-      </ul></li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.AutoGenerator.get_user_content">get_user_content() (praisonai.auto.AutoGenerator method)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.goal">goal (praisonai.auto.RoleDetails attribute)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="I">I</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.agents_generator.AgentsGenerator.is_function_or_decorated">is_function_or_decorated() (praisonai.agents_generator.AgentsGenerator method)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="L">L</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.agents_generator.AgentsGenerator.load_tools_from_module">load_tools_from_module() (praisonai.agents_generator.AgentsGenerator method)</a>
-</li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.agents_generator.AgentsGenerator.load_tools_from_package">load_tools_from_package() (praisonai.agents_generator.AgentsGenerator method)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="M">M</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.cli.PraisonAI.main">main() (praisonai.cli.PraisonAI method)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.model_computed_fields">model_computed_fields (praisonai.auto.RoleDetails attribute)</a>
-
-      <ul>
-        <li><a href="source/praisonai.html#praisonai.auto.TaskDetails.model_computed_fields">(praisonai.auto.TaskDetails attribute)</a>
-</li>
-        <li><a href="source/praisonai.html#praisonai.auto.TeamStructure.model_computed_fields">(praisonai.auto.TeamStructure attribute)</a>
-</li>
-      </ul></li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.model_config">model_config (praisonai.auto.RoleDetails attribute)</a>
-
-      <ul>
-        <li><a href="source/praisonai.html#praisonai.auto.TaskDetails.model_config">(praisonai.auto.TaskDetails attribute)</a>
-</li>
-        <li><a href="source/praisonai.html#praisonai.auto.TeamStructure.model_config">(praisonai.auto.TeamStructure attribute)</a>
-</li>
-      </ul></li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.model_fields">model_fields (praisonai.auto.RoleDetails attribute)</a>
-
-      <ul>
-        <li><a href="source/praisonai.html#praisonai.auto.TaskDetails.model_fields">(praisonai.auto.TaskDetails attribute)</a>
-</li>
-        <li><a href="source/praisonai.html#praisonai.auto.TeamStructure.model_fields">(praisonai.auto.TeamStructure attribute)</a>
-</li>
-      </ul></li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li>
-    module
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai">praisonai</a>
-</li>
-        <li><a href="source/praisonai.html#module-praisonai.agents_generator">praisonai.agents_generator</a>
-</li>
-        <li><a href="source/praisonai.html#module-praisonai.auto">praisonai.auto</a>
-</li>
-        <li><a href="source/praisonai.html#module-praisonai.cli">praisonai.cli</a>
-</li>
-        <li><a href="source/praisonai.html#module-praisonai.deploy">praisonai.deploy</a>
-</li>
-        <li><a href="source/praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools">praisonai.inbuilt_tools</a>
-</li>
-        <li><a href="source/praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools.autogen_tools">praisonai.inbuilt_tools.autogen_tools</a>
-</li>
-        <li><a href="source/praisonai.html#module-praisonai.test">praisonai.test</a>
-</li>
-        <li><a href="source/praisonai.html#module-praisonai.version">praisonai.version</a>
-</li>
-      </ul></li>
-  </ul></td>
-</tr></table>
-
-<h2 id="P">P</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.cli.PraisonAI.parse_args">parse_args() (praisonai.cli.PraisonAI method)</a>
-</li>
-      <li>
-    praisonai
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai">module</a>
-</li>
-      </ul></li>
-      <li><a href="source/praisonai.html#praisonai.cli.PraisonAI">PraisonAI (class in praisonai.cli)</a>
-</li>
-      <li>
-    praisonai.agents_generator
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai.agents_generator">module</a>
-</li>
-      </ul></li>
-      <li>
-    praisonai.auto
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai.auto">module</a>
-</li>
-      </ul></li>
-      <li>
-    praisonai.cli
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai.cli">module</a>
-</li>
-      </ul></li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li>
-    praisonai.deploy
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai.deploy">module</a>
-</li>
-      </ul></li>
-      <li>
-    praisonai.inbuilt_tools
-
-      <ul>
-        <li><a href="source/praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools">module</a>
-</li>
-      </ul></li>
-      <li>
-    praisonai.inbuilt_tools.autogen_tools
-
-      <ul>
-        <li><a href="source/praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools.autogen_tools">module</a>
-</li>
-      </ul></li>
-      <li>
-    praisonai.test
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai.test">module</a>
-</li>
-      </ul></li>
-      <li>
-    praisonai.version
-
-      <ul>
-        <li><a href="source/praisonai.html#module-praisonai.version">module</a>
-</li>
-      </ul></li>
-  </ul></td>
-</tr></table>
-
-<h2 id="R">R</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.role">role (praisonai.auto.RoleDetails attribute)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails">RoleDetails (class in praisonai.auto)</a>
-</li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.TeamStructure.roles">roles (praisonai.auto.TeamStructure attribute)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.deploy.CloudDeployer.run_commands">run_commands() (praisonai.deploy.CloudDeployer method)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="S">S</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.deploy.CloudDeployer.set_environment_variables">set_environment_variables() (praisonai.deploy.CloudDeployer method)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-<h2 id="T">T</h2>
-<table style="width: 100%" class="indextable genindextable"><tr>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.TaskDetails">TaskDetails (class in praisonai.auto)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.tasks">tasks (praisonai.auto.RoleDetails attribute)</a>
-</li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="source/praisonai.html#praisonai.auto.TeamStructure">TeamStructure (class in praisonai.auto)</a>
-</li>
-      <li><a href="source/praisonai.html#praisonai.auto.RoleDetails.tools">tools (praisonai.auto.RoleDetails attribute)</a>
-</li>
-  </ul></td>
-</tr></table>
-
-
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="index.html">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="index.html">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-    </div>
-
-    
-
-    
-  </body>
-</html>

_build/html/index.html

@@ -1,112 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="./">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
-
-    <title>Welcome to PraisonAI’s documentation! &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="_static/alabaster.css?v=12dfc556" />
-    <script src="_static/jquery.js?v=5d32c60e"></script>
-    <script src="_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="_static/documentation_options.js?v=a11416ff"></script>
-    <script src="_static/doctools.js?v=9a2dae69"></script>
-    <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="genindex.html" />
-    <link rel="search" title="Search" href="search.html" />
-   
-  <link rel="stylesheet" href="_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-  <section id="welcome-to-praisonai-s-documentation">
-<h1>Welcome to PraisonAI’s documentation!<a class="headerlink" href="#welcome-to-praisonai-s-documentation" title="Link to this heading"></a></h1>
-<div class="toctree-wrapper compound">
-</div>
-</section>
-<section id="indices-and-tables">
-<h1>Indices and tables<a class="headerlink" href="#indices-and-tables" title="Link to this heading"></a></h1>
-<ul class="simple">
-<li><p><a class="reference internal" href="genindex.html"><span class="std std-ref">Index</span></a></p></li>
-<li><p><a class="reference internal" href="py-modindex.html"><span class="std std-ref">Module Index</span></a></p></li>
-<li><p><a class="reference internal" href="search.html"><span class="std std-ref">Search Page</span></a></p></li>
-</ul>
-</section>
-
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="#">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="#">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-      |
-      <a href="_sources/index.rst.txt"
-          rel="nofollow">Page source</a>
-    </div>
-
-    
-
-    
-  </body>
-</html>

_build/html/py-modindex.html

@@ -1,156 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="./">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Python Module Index &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="_static/alabaster.css?v=12dfc556" />
-    <script src="_static/jquery.js?v=5d32c60e"></script>
-    <script src="_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="_static/documentation_options.js?v=a11416ff"></script>
-    <script src="_static/doctools.js?v=9a2dae69"></script>
-    <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="genindex.html" />
-    <link rel="search" title="Search" href="search.html" />
-
-   
-  <link rel="stylesheet" href="_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-
-   <h1>Python Module Index</h1>
-
-   <div class="modindex-jumpbox">
-   <a href="#cap-p"><strong>p</strong></a>
-   </div>
-
-   <table class="indextable modindextable">
-     <tr class="pcap"><td></td><td>&#160;</td><td></td></tr>
-     <tr class="cap" id="cap-p"><td></td><td>
-       <strong>p</strong></td><td></td></tr>
-     <tr>
-       <td><img src="_static/minus.png" class="toggler"
-              id="toggle-1" style="display: none" alt="-" /></td>
-       <td>
-       <a href="source/praisonai.html#module-praisonai"><code class="xref">praisonai</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.html#module-praisonai.agents_generator"><code class="xref">praisonai.agents_generator</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.html#module-praisonai.auto"><code class="xref">praisonai.auto</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.html#module-praisonai.cli"><code class="xref">praisonai.cli</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.html#module-praisonai.deploy"><code class="xref">praisonai.deploy</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools"><code class="xref">praisonai.inbuilt_tools</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools.autogen_tools"><code class="xref">praisonai.inbuilt_tools.autogen_tools</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.html#module-praisonai.test"><code class="xref">praisonai.test</code></a></td><td>
-       <em></em></td></tr>
-     <tr class="cg-1">
-       <td></td>
-       <td>&#160;&#160;&#160;
-       <a href="source/praisonai.html#module-praisonai.version"><code class="xref">praisonai.version</code></a></td><td>
-       <em></em></td></tr>
-   </table>
-
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="index.html">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="index.html">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-    </div>
-
-    
-
-    
-  </body>
-</html>

_build/html/search.html

@@ -1,118 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="./">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Search &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="_static/alabaster.css?v=12dfc556" />
-    
-    <script src="_static/jquery.js?v=5d32c60e"></script>
-    <script src="_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="_static/documentation_options.js?v=a11416ff"></script>
-    <script src="_static/doctools.js?v=9a2dae69"></script>
-    <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
-    <script src="_static/searchtools.js"></script>
-    <script src="_static/language_data.js"></script>
-    <link rel="index" title="Index" href="genindex.html" />
-    <link rel="search" title="Search" href="#" />
-    <script src="searchindex.js" defer="defer"></script>
-    <meta name="robots" content="noindex" />
-    
-   
-  <link rel="stylesheet" href="_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-  <h1 id="search-documentation">Search</h1>
-  
-  <noscript>
-  <div class="admonition warning">
-  <p>
-    Please activate JavaScript to enable the search
-    functionality.
-  </p>
-  </div>
-  </noscript>
-  
-  
-  <p>
-    Searching for multiple words only shows matches that contain
-    all words.
-  </p>
-  
-  
-  <form action="" method="get">
-    <input type="text" name="q" aria-labelledby="search-documentation" value="" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-    <input type="submit" value="search" />
-    <span id="search-progress" style="padding-left: 10px"></span>
-  </form>
-  
-  
-  <div id="search-results"></div>
-  
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="index.html">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="index.html">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-    </div>
-
-    
-
-    
-  </body>
-</html>

_build/html/searchindex.js

@@ -1 +0,0 @@
-Search.setIndex({"alltitles": {"Indices and tables": [[0, "indices-and-tables"]], "Module contents": [[2, "module-praisonai"], [3, "module-praisonai.inbuilt_tools"]], "Submodules": [[2, "submodules"], [3, "submodules"]], "Subpackages": [[2, "subpackages"]], "Welcome to PraisonAI\u2019s documentation!": [[0, "welcome-to-praisonai-s-documentation"]], "praisonai": [[1, "praisonai"]], "praisonai package": [[2, "praisonai-package"]], "praisonai.agents_generator module": [[2, "module-praisonai.agents_generator"]], "praisonai.auto module": [[2, "module-praisonai.auto"]], "praisonai.cli module": [[2, "module-praisonai.cli"]], "praisonai.deploy module": [[2, "module-praisonai.deploy"]], "praisonai.inbuilt_tools package": [[3, "praisonai-inbuilt-tools-package"]], "praisonai.inbuilt_tools.autogen_tools module": [[3, "module-praisonai.inbuilt_tools.autogen_tools"]], "praisonai.test module": [[2, "module-praisonai.test"]], "praisonai.version module": [[2, "module-praisonai.version"]]}, "docnames": ["index", "source/modules", "source/praisonai", "source/praisonai.inbuilt_tools"], "envversion": {"sphinx": 61, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2}, "filenames": ["index.rst", "source/modules.rst", "source/praisonai.rst", "source/praisonai.inbuilt_tools.rst"], "indexentries": {"agentsgenerator (class in praisonai.agents_generator)": [[2, "praisonai.agents_generator.AgentsGenerator", false]], "autogen_codedocssearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_CodeDocsSearchTool", false]], "autogen_csvsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_CSVSearchTool", false]], "autogen_directoryreadtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_DirectoryReadTool", false]], "autogen_directorysearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_DirectorySearchTool", false]], "autogen_docxsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_DOCXSearchTool", false]], "autogen_filereadtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_FileReadTool", false]], "autogen_jsonsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_JSONSearchTool", false]], "autogen_mdxsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_MDXSearchTool", false]], "autogen_pdfsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_PDFSearchTool", false]], "autogen_ragtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_RagTool", false]], "autogen_scrapeelementfromwebsitetool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeElementFromWebsiteTool", false]], "autogen_scrapewebsitetool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeWebsiteTool", false]], "autogen_txtsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_TXTSearchTool", false]], "autogen_websitesearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_WebsiteSearchTool", false]], "autogen_xmlsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_XMLSearchTool", false]], "autogen_youtubechannelsearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeChannelSearchTool", false]], "autogen_youtubevideosearchtool() (in module praisonai.inbuilt_tools.autogen_tools)": [[3, "praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeVideoSearchTool", false]], "autogenerator (class in praisonai.auto)": [[2, "praisonai.auto.AutoGenerator", false]], "backstory (praisonai.auto.roledetails attribute)": [[2, "praisonai.auto.RoleDetails.backstory", false]], "clouddeployer (class in praisonai.deploy)": [[2, "praisonai.deploy.CloudDeployer", false]], "convert_and_save() (praisonai.auto.autogenerator method)": [[2, "praisonai.auto.AutoGenerator.convert_and_save", false]], "create_api_file() (praisonai.deploy.clouddeployer method)": [[2, "praisonai.deploy.CloudDeployer.create_api_file", false]], "create_dockerfile() (praisonai.deploy.clouddeployer method)": [[2, "praisonai.deploy.CloudDeployer.create_dLine truncated

_build/html/source/modules.html

@@ -1,189 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="../">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
-
-    <title>praisonai &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="../_static/alabaster.css?v=12dfc556" />
-    <script src="../_static/jquery.js?v=5d32c60e"></script>
-    <script src="../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="../_static/documentation_options.js?v=a11416ff"></script>
-    <script src="../_static/doctools.js?v=9a2dae69"></script>
-    <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="../genindex.html" />
-    <link rel="search" title="Search" href="../search.html" />
-   
-  <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-  <section id="praisonai">
-<h1>praisonai<a class="headerlink" href="#praisonai" title="Link to this heading"></a></h1>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="praisonai.html">praisonai package</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#subpackages">Subpackages</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html">praisonai.inbuilt_tools package</a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.inbuilt_tools.html#submodules">Submodules</a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools.autogen_tools">praisonai.inbuilt_tools.autogen_tools module</a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools">Module contents</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#submodules">Submodules</a></li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai.agents_generator">praisonai.agents_generator module</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.agents_generator.AgentsGenerator"><code class="docutils literal notranslate"><span class="pre">AgentsGenerator</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.agents_generator.AgentsGenerator.generate_crew_and_kickoff"><code class="docutils literal notranslate"><span class="pre">AgentsGenerator.generate_crew_and_kickoff()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.agents_generator.AgentsGenerator.is_function_or_decorated"><code class="docutils literal notranslate"><span class="pre">AgentsGenerator.is_function_or_decorated()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.agents_generator.AgentsGenerator.load_tools_from_module"><code class="docutils literal notranslate"><span class="pre">AgentsGenerator.load_tools_from_module()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.agents_generator.AgentsGenerator.load_tools_from_package"><code class="docutils literal notranslate"><span class="pre">AgentsGenerator.load_tools_from_package()</span></code></a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai.auto">praisonai.auto module</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.auto.AutoGenerator"><code class="docutils literal notranslate"><span class="pre">AutoGenerator</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.AutoGenerator.convert_and_save"><code class="docutils literal notranslate"><span class="pre">AutoGenerator.convert_and_save()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.AutoGenerator.generate"><code class="docutils literal notranslate"><span class="pre">AutoGenerator.generate()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.AutoGenerator.get_user_content"><code class="docutils literal notranslate"><span class="pre">AutoGenerator.get_user_content()</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails"><code class="docutils literal notranslate"><span class="pre">RoleDetails</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.backstory"><code class="docutils literal notranslate"><span class="pre">RoleDetails.backstory</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.goal"><code class="docutils literal notranslate"><span class="pre">RoleDetails.goal</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.model_computed_fields"><code class="docutils literal notranslate"><span class="pre">RoleDetails.model_computed_fields</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.model_config"><code class="docutils literal notranslate"><span class="pre">RoleDetails.model_config</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.model_fields"><code class="docutils literal notranslate"><span class="pre">RoleDetails.model_fields</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.role"><code class="docutils literal notranslate"><span class="pre">RoleDetails.role</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.tasks"><code class="docutils literal notranslate"><span class="pre">RoleDetails.tasks</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.RoleDetails.tools"><code class="docutils literal notranslate"><span class="pre">RoleDetails.tools</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.auto.TaskDetails"><code class="docutils literal notranslate"><span class="pre">TaskDetails</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TaskDetails.description"><code class="docutils literal notranslate"><span class="pre">TaskDetails.description</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TaskDetails.expected_output"><code class="docutils literal notranslate"><span class="pre">TaskDetails.expected_output</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TaskDetails.model_computed_fields"><code class="docutils literal notranslate"><span class="pre">TaskDetails.model_computed_fields</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TaskDetails.model_config"><code class="docutils literal notranslate"><span class="pre">TaskDetails.model_config</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TaskDetails.model_fields"><code class="docutils literal notranslate"><span class="pre">TaskDetails.model_fields</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.auto.TeamStructure"><code class="docutils literal notranslate"><span class="pre">TeamStructure</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TeamStructure.model_computed_fields"><code class="docutils literal notranslate"><span class="pre">TeamStructure.model_computed_fields</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TeamStructure.model_config"><code class="docutils literal notranslate"><span class="pre">TeamStructure.model_config</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TeamStructure.model_fields"><code class="docutils literal notranslate"><span class="pre">TeamStructure.model_fields</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.auto.TeamStructure.roles"><code class="docutils literal notranslate"><span class="pre">TeamStructure.roles</span></code></a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai.cli">praisonai.cli module</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.cli.PraisonAI"><code class="docutils literal notranslate"><span class="pre">PraisonAI</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.cli.PraisonAI.create_gradio_interface"><code class="docutils literal notranslate"><span class="pre">PraisonAI.create_gradio_interface()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.cli.PraisonAI.main"><code class="docutils literal notranslate"><span class="pre">PraisonAI.main()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.cli.PraisonAI.parse_args"><code class="docutils literal notranslate"><span class="pre">PraisonAI.parse_args()</span></code></a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai.deploy">praisonai.deploy module</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.deploy.CloudDeployer"><code class="docutils literal notranslate"><span class="pre">CloudDeployer</span></code></a><ul>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.deploy.CloudDeployer.create_api_file"><code class="docutils literal notranslate"><span class="pre">CloudDeployer.create_api_file()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.deploy.CloudDeployer.create_dockerfile"><code class="docutils literal notranslate"><span class="pre">CloudDeployer.create_dockerfile()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.deploy.CloudDeployer.run_commands"><code class="docutils literal notranslate"><span class="pre">CloudDeployer.run_commands()</span></code></a></li>
-<li class="toctree-l4"><a class="reference internal" href="praisonai.html#praisonai.deploy.CloudDeployer.set_environment_variables"><code class="docutils literal notranslate"><span class="pre">CloudDeployer.set_environment_variables()</span></code></a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai.test">praisonai.test module</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.html#praisonai.test.generate_crew_and_kickoff"><code class="docutils literal notranslate"><span class="pre">generate_crew_and_kickoff()</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai.version">praisonai.version module</a></li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.html#module-praisonai">Module contents</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</section>
-
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="../index.html">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="../index.html">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-      |
-      <a href="../_sources/source/modules.rst.txt"
-          rel="nofollow">Page source</a>
-    </div>
-
-    
-
-    
-  </body>
-</html>

_build/html/source/praisonai.html

@@ -1,386 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="../">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
-
-    <title>praisonai package &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="../_static/alabaster.css?v=12dfc556" />
-    <script src="../_static/jquery.js?v=5d32c60e"></script>
-    <script src="../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="../_static/documentation_options.js?v=a11416ff"></script>
-    <script src="../_static/doctools.js?v=9a2dae69"></script>
-    <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="../genindex.html" />
-    <link rel="search" title="Search" href="../search.html" />
-   
-  <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-  <section id="praisonai-package">
-<h1>praisonai package<a class="headerlink" href="#praisonai-package" title="Link to this heading"></a></h1>
-<section id="subpackages">
-<h2>Subpackages<a class="headerlink" href="#subpackages" title="Link to this heading"></a></h2>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="praisonai.inbuilt_tools.html">praisonai.inbuilt_tools package</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.inbuilt_tools.html#submodules">Submodules</a></li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools.autogen_tools">praisonai.inbuilt_tools.autogen_tools module</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_CSVSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_CSVSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_CodeDocsSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_CodeDocsSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_DOCXSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_DOCXSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_DirectoryReadTool"><code class="docutils literal notranslate"><span class="pre">autogen_DirectoryReadTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_DirectorySearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_DirectorySearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_FileReadTool"><code class="docutils literal notranslate"><span class="pre">autogen_FileReadTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_JSONSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_JSONSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_MDXSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_MDXSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_PDFSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_PDFSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_RagTool"><code class="docutils literal notranslate"><span class="pre">autogen_RagTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeElementFromWebsiteTool"><code class="docutils literal notranslate"><span class="pre">autogen_ScrapeElementFromWebsiteTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeWebsiteTool"><code class="docutils literal notranslate"><span class="pre">autogen_ScrapeWebsiteTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_TXTSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_TXTSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_WebsiteSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_WebsiteSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_XMLSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_XMLSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeChannelSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_YoutubeChannelSearchTool()</span></code></a></li>
-<li class="toctree-l3"><a class="reference internal" href="praisonai.inbuilt_tools.html#praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeVideoSearchTool"><code class="docutils literal notranslate"><span class="pre">autogen_YoutubeVideoSearchTool()</span></code></a></li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="praisonai.inbuilt_tools.html#module-praisonai.inbuilt_tools">Module contents</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</section>
-<section id="submodules">
-<h2>Submodules<a class="headerlink" href="#submodules" title="Link to this heading"></a></h2>
-</section>
-<section id="module-praisonai.agents_generator">
-<span id="praisonai-agents-generator-module"></span><h2>praisonai.agents_generator module<a class="headerlink" href="#module-praisonai.agents_generator" title="Link to this heading"></a></h2>
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.agents_generator.AgentsGenerator">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.agents_generator.</span></span><span class="sig-name descname"><span class="pre">AgentsGenerator</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">agent_file</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">framework</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">config_list</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.agents_generator.AgentsGenerator" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p>
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.agents_generator.AgentsGenerator.generate_crew_and_kickoff">
-<span class="sig-name descname"><span class="pre">generate_crew_and_kickoff</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.agents_generator.AgentsGenerator.generate_crew_and_kickoff" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.agents_generator.AgentsGenerator.is_function_or_decorated">
-<span class="sig-name descname"><span class="pre">is_function_or_decorated</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.agents_generator.AgentsGenerator.is_function_or_decorated" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.agents_generator.AgentsGenerator.load_tools_from_module">
-<span class="sig-name descname"><span class="pre">load_tools_from_module</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">module_path</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.agents_generator.AgentsGenerator.load_tools_from_module" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.agents_generator.AgentsGenerator.load_tools_from_package">
-<span class="sig-name descname"><span class="pre">load_tools_from_package</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">package_path</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.agents_generator.AgentsGenerator.load_tools_from_package" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</dd></dl>
-
-</section>
-<section id="module-praisonai.auto">
-<span id="praisonai-auto-module"></span><h2>praisonai.auto module<a class="headerlink" href="#module-praisonai.auto" title="Link to this heading"></a></h2>
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.auto.AutoGenerator">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.auto.</span></span><span class="sig-name descname"><span class="pre">AutoGenerator</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">topic</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'Movie</span> <span class="pre">Story</span> <span class="pre">writing</span> <span class="pre">about</span> <span class="pre">AI'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">agent_file</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'test.yaml'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">framework</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'crewai'</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.AutoGenerator" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p>
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.auto.AutoGenerator.convert_and_save">
-<span class="sig-name descname"><span class="pre">convert_and_save</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">json_data</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.AutoGenerator.convert_and_save" title="Link to this definition"></a></dt>
-<dd><p>Converts the provided JSON data into the desired YAML format and saves it to a file.</p>
-<dl class="field-list simple">
-<dt class="field-odd">Parameters<span class="colon">:</span></dt>
-<dd class="field-odd"><ul class="simple">
-<li><p><strong>json_data</strong> (<em>dict</em>) – The JSON data representing the team structure.</p></li>
-<li><p><strong>topic</strong> (<em>str</em><em>, </em><em>optional</em>) – The topic to be inserted into the YAML. Defaults to “Artificial Intelligence”.</p></li>
-<li><p><strong>agent_file</strong> (<em>str</em><em>, </em><em>optional</em>) – The name of the YAML file to save. Defaults to “test.yaml”.</p></li>
-</ul>
-</dd>
-</dl>
-</dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.auto.AutoGenerator.generate">
-<span class="sig-name descname"><span class="pre">generate</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.AutoGenerator.generate" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.auto.AutoGenerator.get_user_content">
-<span class="sig-name descname"><span class="pre">get_user_content</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.AutoGenerator.get_user_content" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</dd></dl>
-
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.auto.</span></span><span class="sig-name descname"><span class="pre">RoleDetails</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">role</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">goal</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">backstory</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tasks</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><a class="reference internal" href="#praisonai.auto.TaskDetails" title="praisonai.auto.TaskDetails"><span class="pre">TaskDetails</span></a><span class="p"><span class="pre">]</span></span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tools</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">List</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.RoleDetails" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">BaseModel</span></code></p>
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.backstory">
-<span class="sig-name descname"><span class="pre">backstory</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">str</span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.backstory" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.goal">
-<span class="sig-name descname"><span class="pre">goal</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">str</span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.goal" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.model_computed_fields">
-<span class="sig-name descname"><span class="pre">model_computed_fields</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">ComputedFieldInfo</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{}</span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.model_computed_fields" title="Link to this definition"></a></dt>
-<dd><p>A dictionary of computed field names and their corresponding <cite>ComputedFieldInfo</cite> objects.</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.model_config">
-<span class="sig-name descname"><span class="pre">model_config</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">ConfigDict</span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{}</span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.model_config" title="Link to this definition"></a></dt>
-<dd><p>Configuration for the model, should be a dictionary conforming to [<cite>ConfigDict</cite>][pydantic.config.ConfigDict].</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.model_fields">
-<span class="sig-name descname"><span class="pre">model_fields</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">FieldInfo</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{'backstory':</span> <span class="pre">FieldInfo(annotation=str,</span> <span class="pre">required=True),</span> <span class="pre">'goal':</span> <span class="pre">FieldInfo(annotation=str,</span> <span class="pre">required=True),</span> <span class="pre">'role':</span> <span class="pre">FieldInfo(annotation=str,</span> <span class="pre">required=True),</span> <span class="pre">'tasks':</span> <span class="pre">FieldInfo(annotation=Dict[str,</span> <span class="pre">TaskDetails],</span> <span class="pre">required=True),</span> <span class="pre">'tools':</span> <span class="pre">FieldInfo(annotation=List[str],</span> <span class="pre">required=True)}</span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.model_fields" title="Link to this definition"></a></dt>
-<dd><p>Metadata about the fields defined on the model,
-mapping of field names to [<cite>FieldInfo</cite>][pydantic.fields.FieldInfo].</p>
-<p>This replaces <cite>Model.__fields__</cite> from Pydantic V1.</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.role">
-<span class="sig-name descname"><span class="pre">role</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">str</span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.role" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.tasks">
-<span class="sig-name descname"><span class="pre">tasks</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><a class="reference internal" href="#praisonai.auto.TaskDetails" title="praisonai.auto.TaskDetails"><span class="pre">TaskDetails</span></a><span class="p"><span class="pre">]</span></span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.tasks" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.RoleDetails.tools">
-<span class="sig-name descname"><span class="pre">tools</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">List</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">]</span></span></em><a class="headerlink" href="#praisonai.auto.RoleDetails.tools" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</dd></dl>
-
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.auto.TaskDetails">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.auto.</span></span><span class="sig-name descname"><span class="pre">TaskDetails</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">description</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">expected_output</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">str</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.TaskDetails" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">BaseModel</span></code></p>
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TaskDetails.description">
-<span class="sig-name descname"><span class="pre">description</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">str</span></em><a class="headerlink" href="#praisonai.auto.TaskDetails.description" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TaskDetails.expected_output">
-<span class="sig-name descname"><span class="pre">expected_output</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">str</span></em><a class="headerlink" href="#praisonai.auto.TaskDetails.expected_output" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TaskDetails.model_computed_fields">
-<span class="sig-name descname"><span class="pre">model_computed_fields</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">ComputedFieldInfo</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{}</span></em><a class="headerlink" href="#praisonai.auto.TaskDetails.model_computed_fields" title="Link to this definition"></a></dt>
-<dd><p>A dictionary of computed field names and their corresponding <cite>ComputedFieldInfo</cite> objects.</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TaskDetails.model_config">
-<span class="sig-name descname"><span class="pre">model_config</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">ConfigDict</span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{}</span></em><a class="headerlink" href="#praisonai.auto.TaskDetails.model_config" title="Link to this definition"></a></dt>
-<dd><p>Configuration for the model, should be a dictionary conforming to [<cite>ConfigDict</cite>][pydantic.config.ConfigDict].</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TaskDetails.model_fields">
-<span class="sig-name descname"><span class="pre">model_fields</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">FieldInfo</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{'description':</span> <span class="pre">FieldInfo(annotation=str,</span> <span class="pre">required=True),</span> <span class="pre">'expected_output':</span> <span class="pre">FieldInfo(annotation=str,</span> <span class="pre">required=True)}</span></em><a class="headerlink" href="#praisonai.auto.TaskDetails.model_fields" title="Link to this definition"></a></dt>
-<dd><p>Metadata about the fields defined on the model,
-mapping of field names to [<cite>FieldInfo</cite>][pydantic.fields.FieldInfo].</p>
-<p>This replaces <cite>Model.__fields__</cite> from Pydantic V1.</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.auto.TeamStructure">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.auto.</span></span><span class="sig-name descname"><span class="pre">TeamStructure</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">roles</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><a class="reference internal" href="#praisonai.auto.RoleDetails" title="praisonai.auto.RoleDetails"><span class="pre">RoleDetails</span></a><span class="p"><span class="pre">]</span></span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.auto.TeamStructure" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">BaseModel</span></code></p>
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TeamStructure.model_computed_fields">
-<span class="sig-name descname"><span class="pre">model_computed_fields</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">ComputedFieldInfo</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{}</span></em><a class="headerlink" href="#praisonai.auto.TeamStructure.model_computed_fields" title="Link to this definition"></a></dt>
-<dd><p>A dictionary of computed field names and their corresponding <cite>ComputedFieldInfo</cite> objects.</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TeamStructure.model_config">
-<span class="sig-name descname"><span class="pre">model_config</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">ConfigDict</span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{}</span></em><a class="headerlink" href="#praisonai.auto.TeamStructure.model_config" title="Link to this definition"></a></dt>
-<dd><p>Configuration for the model, should be a dictionary conforming to [<cite>ConfigDict</cite>][pydantic.config.ConfigDict].</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TeamStructure.model_fields">
-<span class="sig-name descname"><span class="pre">model_fields</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">ClassVar</span><span class="p"><span class="pre">[</span></span><span class="pre">dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><span class="pre">FieldInfo</span><span class="p"><span class="pre">]</span></span><span class="p"><span class="pre">]</span></span></em><em class="property"><span class="w"> </span><span class="p"><span class="pre">=</span></span><span class="w"> </span><span class="pre">{'roles':</span> <span class="pre">FieldInfo(annotation=Dict[str,</span> <span class="pre">RoleDetails],</span> <span class="pre">required=True)}</span></em><a class="headerlink" href="#praisonai.auto.TeamStructure.model_fields" title="Link to this definition"></a></dt>
-<dd><p>Metadata about the fields defined on the model,
-mapping of field names to [<cite>FieldInfo</cite>][pydantic.fields.FieldInfo].</p>
-<p>This replaces <cite>Model.__fields__</cite> from Pydantic V1.</p>
-</dd></dl>
-
-<dl class="py attribute">
-<dt class="sig sig-object py" id="praisonai.auto.TeamStructure.roles">
-<span class="sig-name descname"><span class="pre">roles</span></span><em class="property"><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="pre">Dict</span><span class="p"><span class="pre">[</span></span><span class="pre">str</span><span class="p"><span class="pre">,</span></span><span class="w"> </span><a class="reference internal" href="#praisonai.auto.RoleDetails" title="praisonai.auto.RoleDetails"><span class="pre">RoleDetails</span></a><span class="p"><span class="pre">]</span></span></em><a class="headerlink" href="#praisonai.auto.TeamStructure.roles" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</dd></dl>
-
-</section>
-<section id="module-praisonai.cli">
-<span id="praisonai-cli-module"></span><h2>praisonai.cli module<a class="headerlink" href="#module-praisonai.cli" title="Link to this heading"></a></h2>
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.cli.PraisonAI">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.cli.</span></span><span class="sig-name descname"><span class="pre">PraisonAI</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">agent_file</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'agents.yaml'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">framework</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'crewai'</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">auto</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">init</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.cli.PraisonAI" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p>
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.cli.PraisonAI.create_gradio_interface">
-<span class="sig-name descname"><span class="pre">create_gradio_interface</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.cli.PraisonAI.create_gradio_interface" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.cli.PraisonAI.main">
-<span class="sig-name descname"><span class="pre">main</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.cli.PraisonAI.main" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.cli.PraisonAI.parse_args">
-<span class="sig-name descname"><span class="pre">parse_args</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.cli.PraisonAI.parse_args" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</dd></dl>
-
-</section>
-<section id="module-praisonai.deploy">
-<span id="praisonai-deploy-module"></span><h2>praisonai.deploy module<a class="headerlink" href="#module-praisonai.deploy" title="Link to this heading"></a></h2>
-<dl class="py class">
-<dt class="sig sig-object py" id="praisonai.deploy.CloudDeployer">
-<em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">praisonai.deploy.</span></span><span class="sig-name descname"><span class="pre">CloudDeployer</span></span><a class="headerlink" href="#praisonai.deploy.CloudDeployer" title="Link to this definition"></a></dt>
-<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p>
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.deploy.CloudDeployer.create_api_file">
-<span class="sig-name descname"><span class="pre">create_api_file</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.deploy.CloudDeployer.create_api_file" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.deploy.CloudDeployer.create_dockerfile">
-<span class="sig-name descname"><span class="pre">create_dockerfile</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.deploy.CloudDeployer.create_dockerfile" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.deploy.CloudDeployer.run_commands">
-<span class="sig-name descname"><span class="pre">run_commands</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.deploy.CloudDeployer.run_commands" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py method">
-<dt class="sig sig-object py" id="praisonai.deploy.CloudDeployer.set_environment_variables">
-<span class="sig-name descname"><span class="pre">set_environment_variables</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.deploy.CloudDeployer.set_environment_variables" title="Link to this definition"></a></dt>
-<dd><p>Sets environment variables with fallback to .env values or defaults.</p>
-</dd></dl>
-
-</dd></dl>
-
-</section>
-<section id="module-praisonai.test">
-<span id="praisonai-test-module"></span><h2>praisonai.test module<a class="headerlink" href="#module-praisonai.test" title="Link to this heading"></a></h2>
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.test.generate_crew_and_kickoff">
-<span class="sig-prename descclassname"><span class="pre">praisonai.test.</span></span><span class="sig-name descname"><span class="pre">generate_crew_and_kickoff</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">agent_file</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.test.generate_crew_and_kickoff" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</section>
-<section id="module-praisonai.version">
-<span id="praisonai-version-module"></span><h2>praisonai.version module<a class="headerlink" href="#module-praisonai.version" title="Link to this heading"></a></h2>
-</section>
-<section id="module-praisonai">
-<span id="module-contents"></span><h2>Module contents<a class="headerlink" href="#module-praisonai" title="Link to this heading"></a></h2>
-</section>
-</section>
-
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="../index.html">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="../index.html">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-      |
-      <a href="../_sources/source/praisonai.rst.txt"
-          rel="nofollow">Page source</a>
-    </div>
-
-    
-
-    
-  </body>
-</html>

_build/html/source/praisonai.inbuilt_tools.html

@@ -1,196 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" data-content_root="../">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
-
-    <title>praisonai.inbuilt_tools package &#8212; PraisonAI 0.0.21 documentation</title>
-    <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=d1102ebc" />
-    <link rel="stylesheet" type="text/css" href="../_static/alabaster.css?v=12dfc556" />
-    <script src="../_static/jquery.js?v=5d32c60e"></script>
-    <script src="../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-    <script src="../_static/documentation_options.js?v=a11416ff"></script>
-    <script src="../_static/doctools.js?v=9a2dae69"></script>
-    <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
-    <link rel="index" title="Index" href="../genindex.html" />
-    <link rel="search" title="Search" href="../search.html" />
-   
-  <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
-  
-
-  
-  
-
-  </head><body>
-  
-
-    <div class="document">
-      <div class="documentwrapper">
-        <div class="bodywrapper">
-          
-
-          <div class="body" role="main">
-            
-  <section id="praisonai-inbuilt-tools-package">
-<h1>praisonai.inbuilt_tools package<a class="headerlink" href="#praisonai-inbuilt-tools-package" title="Link to this heading"></a></h1>
-<section id="submodules">
-<h2>Submodules<a class="headerlink" href="#submodules" title="Link to this heading"></a></h2>
-</section>
-<section id="module-praisonai.inbuilt_tools.autogen_tools">
-<span id="praisonai-inbuilt-tools-autogen-tools-module"></span><h2>praisonai.inbuilt_tools.autogen_tools module<a class="headerlink" href="#module-praisonai.inbuilt_tools.autogen_tools" title="Link to this heading"></a></h2>
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_CSVSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_CSVSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_CSVSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_CodeDocsSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_CodeDocsSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_CodeDocsSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_DOCXSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_DOCXSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_DOCXSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_DirectoryReadTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_DirectoryReadTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_DirectoryReadTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_DirectorySearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_DirectorySearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_DirectorySearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_FileReadTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_FileReadTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_FileReadTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_JSONSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_JSONSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_JSONSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_MDXSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_MDXSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_MDXSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_PDFSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_PDFSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_PDFSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_RagTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_RagTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_RagTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeElementFromWebsiteTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_ScrapeElementFromWebsiteTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeElementFromWebsiteTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeWebsiteTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_ScrapeWebsiteTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_ScrapeWebsiteTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_TXTSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_TXTSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_TXTSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_WebsiteSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_WebsiteSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_WebsiteSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_XMLSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_XMLSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_XMLSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeChannelSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_YoutubeChannelSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeChannelSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-<dl class="py function">
-<dt class="sig sig-object py" id="praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeVideoSearchTool">
-<span class="sig-prename descclassname"><span class="pre">praisonai.inbuilt_tools.autogen_tools.</span></span><span class="sig-name descname"><span class="pre">autogen_YoutubeVideoSearchTool</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">assistant</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">user_proxy</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#praisonai.inbuilt_tools.autogen_tools.autogen_YoutubeVideoSearchTool" title="Link to this definition"></a></dt>
-<dd></dd></dl>
-
-</section>
-<section id="module-praisonai.inbuilt_tools">
-<span id="module-contents"></span><h2>Module contents<a class="headerlink" href="#module-praisonai.inbuilt_tools" title="Link to this heading"></a></h2>
-</section>
-</section>
-
-
-          </div>
-          
-        </div>
-      </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-<h1 class="logo"><a href="../index.html">PraisonAI</a></h1>
-
-
-
-
-
-
-
-
-<h3>Navigation</h3>
-
-<div class="relations">
-<h3>Related Topics</h3>
-<ul>
-  <li><a href="../index.html">Documentation overview</a><ul>
-  </ul></li>
-</ul>
-</div>
-<search id="searchbox" style="display: none" role="search">
-  <h3 id="searchlabel">Quick search</h3>
-    <div class="searchformwrapper">
-    <form class="search" action="../search.html" method="get">
-      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
-      <input type="submit" value="Go" />
-    </form>
-    </div>
-</search>
-<script>document.getElementById('searchbox').style.display = "block"</script>
-
-
-
-
-
-
-
-
-        </div>
-      </div>
-      <div class="clearer"></div>
-    </div>
-    <div class="footer">
-      &#169;2024, Mervin Praison.
-      
-      |
-      Powered by <a href="https://www.sphinx-doc.org/">Sphinx 7.3.7</a>
-      &amp; <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
-      
-      |
-      <a href="../_sources/source/praisonai.inbuilt_tools.rst.txt"
-          rel="nofollow">Page source</a>
-    </div>
-
-    
-
-    
-  </body>
-</html>

agents-advanced.yaml

@@ -0,0 +1,67 @@
+framework: crewai
+topic: research about the causes of lung disease
+roles:
+  research_analyst:
+    backstory: Experienced in analyzing scientific data related to respiratory health.
+    goal: Analyze data on lung diseases
+    role: Research Analyst
+    llm:  
+      model: "groq/llama3-70b-8192"
+    function_calling_llm: 
+      model: "google/gemini-1.5-flash-001"
+    allow_delegation: False
+    max_execution_time: 
+    max_iter: 
+    max_rpm: 
+    verbose: True
+    cache: True
+    system_template: 
+    prompt_template: 
+    response_template: 
+    tasks:
+      data_analysis:
+        description: Gather and analyze data on the causes and risk factors of lung
+          diseases.
+        expected_output: Report detailing key findings on lung disease causes.
+        config: 
+          max_iter: 5
+        output_file: "output/data_analysis.txt"
+    tools:
+    - 'InternetSearchTool'
+  medical_writer:
+    backstory: Skilled in translating complex medical information into accessible
+      content.
+    goal: Compile comprehensive content on lung disease causes
+    role: Medical Writer
+    llm:  
+      model: "anthropic/claude-3-haiku-20240307"
+    function_calling_llm: 
+      model: "openai/gpt-4o"
+    tasks:
+      content_creation:
+        description: Create detailed content summarizing the research findings on
+          lung disease causes.
+        expected_output: Document outlining various causes and risk factors of lung
+          diseases.
+        async_execution: True
+        output_file: "output/medical_writer.txt"
+        create_directory: 
+        context: 
+          - data_analysis
+    tools:
+    - ''
+  editor:
+    backstory: Proficient in editing medical content for accuracy and clarity.
+    goal: Review and refine content on lung disease causes
+    role: Editor
+    llm:  
+      model: "cohere/command-r"
+    tasks:
+      content_review:
+        description: Edit and refine the compiled content on lung disease causes for
+          accuracy and coherence.
+        expected_output: Finalized document on lung disease causes ready for dissemination.
+        output_file: "output/editor.txt"
+    tools:
+    - ''
+dependencies: []

agents.yaml

@@ -0,0 +1,44 @@
+framework: praisonai
+process: sequential
+topic: create movie script about cat in mars
+memory: false
+roles:
+  researcher:
+    backstory: Skilled in research, with a focus on gathering accurate and relevant
+      information.
+    goal: Gather information about Mars and cats
+    role: Researcher
+    min_reflect: 1
+    max_reflect: 2
+    tasks:
+      research_task:
+        description: Research about Mars, its environment, and the feasibility of
+          a cat being on Mars. Also, research about cat behavior and characteristics.
+        expected_output: Document with research findings on Mars and cats.
+    tools:
+    - search_tool
+  narrative_designer:
+    backstory: Skilled in narrative development, with a focus on creating engaging
+      stories.
+    goal: Create a story concept for a movie about a cat in Mars
+    role: Narrative Designer
+    tasks:
+      story_concept_development:
+        description: Use the research findings to craft a unique story concept for
+          a movie about a cat in Mars.
+        expected_output: Document with narrative arcs, character bios, and settings.
+    tools:
+    - ''
+  scriptwriter:
+    backstory: Expert in dialogue and script structure, translating concepts into
+      scripts.
+    goal: Write a movie script about a cat in Mars
+    role: Scriptwriter
+    tasks:
+      scriptwriting_task:
+        description: Turn the story concept into a production-ready movie script,
+          including dialogue and scene details.
+        expected_output: Final movie script with dialogue and scene details.
+    tools:
+    - ''
+dependencies: []

agents/.cursorrules

@@ -0,0 +1,8 @@
+1. Make minimal code changes as possible
+2. if you are creating function, make sure to name it in more easy, user friendly , optimised manner. 
+3. Never copy the exact code if presented with a code from other location or file or codebase, just make it optimised
+4. Always Follow the principle LESS IS MORE
+5. Make it minimal change as possible
+6. Firstly try not to make any modification to the existing code as possible
+7. Only modify the existing code if its highly required, without that if it cant be done, then add new code section. 
+8. If you are adding new code, make sure to add it in a way that it can be easily integrated with the existing codebase. 

agents/.gitignore

@@ -0,0 +1,87 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env
+.venv
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+.project
+.pydevproject
+.settings/
+
+# Testing
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Documentation
+docs/_build/
+docs/generated/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+
+# Logs and databases
+*.log
+*.sqlite
+*.db
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+.test
+praisonaiaagents.egg-info
+praisonaiagents.egg-info
+app.py
+outputs
+praisonaiagents/build
+praisonaiagents/dist
+praisonaiagents/praisonaiagents.egg-info
+dist
+build
+*.mp4 
+*.png 
+graph.py
+chroma_db/

agents/.praisonignore

@@ -0,0 +1,32 @@
+.cursorrules
+.gitignore
+.praisoncontext
+.praisonignore
+.windsurfrules
+async_example.py
+async_example_full.py
+async_example_full_multigroups.py
+auto_agents_example.py
+code_agents_example.py
+example_callback.py
+example_custom_tools.py
+example_sequential.py
+image.jpg
+langchain_example.py
+langchain_logs.py
+long_term.db
+mini_agents_example.py
+multimodal.py
+praisonaiagents/tools/*
+praisonaiagents/process/*
+pyproject.toml
+short_term.db
+structured_agents_example.py
+structured_response_example.py
+test.py
+tools_example.py
+uv.lock
+workflow_example_basic.py
+workflow_example_detailed.py
+__pycache__
+__pycache__/*

agents/.windsurfrules

@@ -0,0 +1,8 @@
+1. Make minimal code changes as possible
+2. if you are creating function, make sure to name it in more easy, user friendly , optimised manner. 
+3. Never copy the exact code if presented with a code from other location or file or codebase, just make it optimised
+4. Always Follow the principle LESS IS MORE
+5. Make it minimal change as possible
+6. Firstly try not to make any modification to the existing code as possible
+7. Only modify the existing code if its highly required, without that if it cant be done, then add new code section. 
+8. If you are adding new code, make sure to add it in a way that it can be easily integrated with the existing codebase. 

agents/async_example.py

@@ -0,0 +1,233 @@
+import asyncio
+import time
+from typing import List, Dict
+from praisonaiagents import Agent, Task, PraisonAIAgents, TaskOutput
+from praisonaiagents.main import (
+    display_error,
+    display_interaction,
+    display_tool_call,
+    display_instruction,
+    error_logs,
+    Console
+)
+from duckduckgo_search import DDGS
+from pydantic import BaseModel
+
+console = Console()
+
+# 1. Define output model for structured results
+class SearchResult(BaseModel):
+    query: str
+    results: List[Dict[str, str]]
+    total_results: int
+
+# 2. Define both sync and async tools
+def sync_search_tool(query: str) -> List[Dict]:
+    """
+    Synchronous search using DuckDuckGo.
+    Args:
+        query (str): The search query.
+    Returns:
+        list: Search results
+    """
+    display_tool_call(f"Running sync search for: {query}", console)
+    time.sleep(1)  # Simulate network delay
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=5):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+    except Exception as e:
+        error_msg = f"Error during sync search: {e}"
+        display_error(error_msg, console)
+        error_logs.append(error_msg)
+        return []
+
+async def async_search_tool(query: str) -> List[Dict]:
+    """
+    Asynchronous search using DuckDuckGo.
+    Args:
+        query (str): The search query.
+    Returns:
+        list: Search results
+    """
+    display_tool_call(f"Running async search for: {query}", console)
+    await asyncio.sleep(1)  # Simulate network delay
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=5):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+    except Exception as e:
+        error_msg = f"Error during async search: {e}"
+        display_error(error_msg, console)
+        error_logs.append(error_msg)
+        return []
+
+# 3. Define both sync and async callbacks
+def sync_callback(output: TaskOutput):
+    display_interaction("Sync Callback", f"Processing output: {output.raw[:100]}...", markdown=True, console=console)
+    time.sleep(1)  # Simulate processing
+    if output.output_format == "JSON":
+        display_tool_call(f"Processed JSON result: {output.json_dict}", console)
+    elif output.output_format == "Pydantic":
+        display_tool_call(f"Processed Pydantic result: {output.pydantic}", console)
+
+async def async_callback(output: TaskOutput):
+    display_interaction("Async Callback", f"Processing output: {output.raw[:100]}...", markdown=True, console=console)
+    await asyncio.sleep(1)  # Simulate processing
+    if output.output_format == "JSON":
+        display_tool_call(f"Processed JSON result: {output.json_dict}", console)
+    elif output.output_format == "Pydantic":
+        display_tool_call(f"Processed Pydantic result: {output.pydantic}", console)
+
+# 4. Create agents with different tools
+sync_agent = Agent(
+    name="SyncAgent",
+    role="Synchronous Search Specialist",
+    goal="Perform synchronous searches and return structured results",
+    backstory="Expert in sync operations and data organization",
+    tools=[sync_search_tool],
+    self_reflect=False,
+    verbose=True,
+    markdown=True
+)
+
+async_agent = Agent(
+    name="AsyncAgent",
+    role="Asynchronous Search Specialist",
+    goal="Perform asynchronous searches and return structured results",
+    backstory="Expert in async operations and data organization",
+    tools=[async_search_tool],
+    self_reflect=False,
+    verbose=True,
+    markdown=True
+)
+
+# 5. Create tasks with different configurations
+sync_task = Task(
+    name="sync_search",
+    description="Search for 'Python programming' using sync tool and return structured results",
+    expected_output="SearchResult model with query details and results",
+    agent=sync_agent,
+    async_execution=False,
+    callback=sync_callback,
+    output_pydantic=SearchResult
+)
+
+async_task = Task(
+    name="async_search",
+    description="Search for 'Async programming' using async tool and return structured results",
+    expected_output="SearchResult model with query details and results",
+    agent=async_agent,
+    async_execution=True,
+    callback=async_callback,
+    output_pydantic=SearchResult
+)
+
+# 6. Create workflow tasks
+workflow_sync_task = Task(
+    name="workflow_sync",
+    description="Workflow sync search for 'AI trends' with structured output",
+    expected_output="SearchResult model with AI trends data",
+    agent=sync_agent,
+    async_execution=False,
+    is_start=True,
+    next_tasks=["workflow_async"],
+    output_pydantic=SearchResult
+)
+
+workflow_async_task = Task(
+    name="workflow_async",
+    description="Workflow async search for 'Future of AI' with structured output",
+    expected_output="SearchResult model with Future of AI data",
+    agent=async_agent,
+    async_execution=True,
+    output_pydantic=SearchResult
+)
+
+# 7. Example usage functions
+def run_sync_example():
+    """Run synchronous example"""
+    display_instruction("\nRunning Synchronous Example...", console)
+    agents = PraisonAIAgents(
+        agents=[sync_agent],
+        tasks=[sync_task],
+        verbose=1,
+        process="sequential"
+    )
+    result = agents.start()
+    display_interaction("Sync Example", f"Result: {result}", markdown=True, console=console)
+
+async def run_async_example():
+    """Run asynchronous example"""
+    display_instruction("\nRunning Asynchronous Example...", console)
+    agents = PraisonAIAgents(
+        agents=[async_agent],
+        tasks=[async_task],
+        verbose=1,
+        process="sequential"
+    )
+    result = await agents.astart()
+    display_interaction("Async Example", f"Result: {result}", markdown=True, console=console)
+
+async def run_mixed_example():
+    """Run mixed sync/async example"""
+    display_instruction("\nRunning Mixed Sync/Async Example...", console)
+    agents = PraisonAIAgents(
+        agents=[sync_agent, async_agent],
+        tasks=[sync_task, async_task],
+        verbose=1,
+        process="sequential"
+    )
+    result = await agents.astart()
+    display_interaction("Mixed Example", f"Result: {result}", markdown=True, console=console)
+
+async def run_workflow_example():
+    """Run workflow example with both sync and async tasks"""
+    display_instruction("\nRunning Workflow Example...", console)
+    agents = PraisonAIAgents(
+        agents=[sync_agent, async_agent],
+        tasks=[workflow_sync_task, workflow_async_task],
+        verbose=1,
+        process="workflow"
+    )
+    result = await agents.astart()
+    display_interaction("Workflow Example", f"Result: {result}", markdown=True, console=console)
+
+# 8. Main execution
+async def main():
+    """Main execution function"""
+    display_instruction("Starting PraisonAI Agents Examples...", console)
+    
+    try:
+        # Run sync example in a separate thread to not block the event loop
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, run_sync_example)
+        
+        # Run async examples
+        await run_async_example()
+        await run_mixed_example()
+        await run_workflow_example()
+
+        if error_logs:
+            display_error("\nErrors encountered during execution:", console)
+            for error in error_logs:
+                display_error(error, console)
+    except Exception as e:
+        display_error(f"Error in main execution: {e}", console)
+        error_logs.append(str(e))
+
+if __name__ == "__main__":
+    # Run the main function
+    asyncio.run(main()) 

agents/async_example_full.py

@@ -0,0 +1,152 @@
+import asyncio
+import time
+from typing import List, Dict
+from praisonaiagents import Agent, Task, PraisonAIAgents, TaskOutput
+from duckduckgo_search import DDGS
+from pydantic import BaseModel
+
+# 1. Define output model for structured results
+class SearchResult(BaseModel):
+    query: str
+    results: List[Dict[str, str]]
+    total_results: int
+
+# 2. Define async tool
+async def async_search_tool(query: str) -> Dict:
+    """Perform asynchronous search and return structured results."""
+    await asyncio.sleep(1)  # Simulate network delay
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=5):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        
+        return {
+            "query": query,
+            "results": results,
+            "total_results": len(results)
+        }
+    except Exception as e:
+        print(f"Error during async search: {e}")
+        return {
+            "query": query,
+            "results": [],
+            "total_results": 0
+        }
+
+# 3. Define async callback
+async def async_callback(output: TaskOutput):
+    await asyncio.sleep(1)  # Simulate processing
+    if output.output_format == "JSON":
+        print(f"Processed JSON result: {output.json_dict}")
+    elif output.output_format == "Pydantic":
+        print(f"Processed Pydantic result: {output.pydantic}")
+
+# 4. Create specialized agents
+async_agent = Agent(
+    name="AsyncSearchAgent",
+    role="Search Specialist",
+    goal="Perform fast parallel searches with structured results",
+    backstory="Expert in efficient data retrieval and parallel search operations",
+    tools=[async_search_tool],
+    self_reflect=False,
+    verbose=True,
+    markdown=True
+)
+
+summary_agent = Agent(
+    name="SummaryAgent",
+    role="Research Synthesizer",
+    goal="Create concise summaries from multiple search results",
+    backstory="Expert in analyzing and synthesizing information from multiple sources",
+    self_reflect=True,
+    verbose=True,
+    markdown=True
+)
+
+# 5. Create async tasks
+async_task = Task(
+    name="async_search",
+    description="Search for 'Async programming' and return results in JSON format with query, results array, and total_results count.",
+    expected_output="SearchResult model with structured data",
+    agent=async_agent,
+    async_execution=True,
+    callback=async_callback,
+    output_json=SearchResult
+)
+
+async def run_parallel_tasks():
+    """Run multiple async tasks in parallel"""
+    print("\nRunning Parallel Async Tasks...")
+    
+    # Define different search topics
+    search_topics = [
+        "Latest AI Developments 2024",
+        "Machine Learning Best Practices",
+        "Neural Networks Architecture"
+    ]
+    
+    # Create tasks for different topics
+    parallel_tasks = [
+        Task(
+            name=f"search_task_{i}",
+            description=f"Search for '{topic}' and return structured results with query details and findings.",
+            expected_output="SearchResult model with search data",
+            agent=async_agent,
+            async_execution=True,
+            callback=async_callback,
+            output_json=SearchResult
+        ) for i, topic in enumerate(search_topics)
+    ]
+    
+    # Create summarization task
+    summary_task = Task(
+        name="summary_task",
+        description="Analyze all search results and create a concise summary highlighting key findings, patterns, and implications.",
+        expected_output="Structured summary with key findings and insights",
+        agent=summary_agent,
+        async_execution=False,
+        callback=async_callback,
+        context=parallel_tasks
+    )
+    
+    # Create a single PraisonAIAgents instance with both agents
+    agents = PraisonAIAgents(
+        agents=[async_agent, summary_agent],
+        tasks=parallel_tasks + [summary_task],
+        verbose=1,
+        process="sequential"
+    )
+    
+    # Run all tasks
+    results = await agents.astart()
+    print(f"Tasks Results: {results}")
+    
+    # Return results in a serializable format
+    return {
+        "search_results": {
+            "task_status": {k: v for k, v in results["task_status"].items() if k != summary_task.id},
+            "task_results": [str(results["task_results"][i]) if results["task_results"][i] else None 
+                           for i in range(len(parallel_tasks))]
+        },
+        "summary": str(results["task_results"][summary_task.id]) if results["task_results"].get(summary_task.id) else None,
+        "topics": search_topics
+    }
+
+# 6. Main execution
+async def main():
+    """Main execution function"""
+    print("Starting Async AI Agents Examples...")
+    
+    try:
+        await run_parallel_tasks()
+    except Exception as e:
+        print(f"Error in main execution: {e}")
+
+if __name__ == "__main__":
+    # Run the main function
+    asyncio.run(main())

agents/async_example_full_multigroups.py

@@ -0,0 +1,248 @@
+import asyncio
+import time
+from typing import List, Dict
+from praisonaiagents import Agent, Task, PraisonAIAgents, TaskOutput
+from duckduckgo_search import DDGS
+from pydantic import BaseModel
+
+# 1. Define output model for structured results
+class SearchResult(BaseModel):
+    query: str
+    results: List[Dict[str, str]]
+    total_results: int
+
+# 2. Define async tool
+async def async_search_tool(query: str) -> Dict:
+    """
+    Asynchronous search using DuckDuckGo.
+    Args:
+        query (str): The search query.
+    Returns:
+        dict: Search results in SearchResult model format
+    """
+    await asyncio.sleep(1)  # Simulate network delay
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=5):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        
+        # Format response to match SearchResult model
+        return {
+            "query": query,
+            "results": results,
+            "total_results": len(results)
+        }
+    except Exception as e:
+        print(f"Error during async search: {e}")
+        return {
+            "query": query,
+            "results": [],
+            "total_results": 0
+        }
+
+# 3. Define async callback
+async def async_callback(output: TaskOutput):
+    await asyncio.sleep(1)  # Simulate processing
+    if output.output_format == "JSON":
+        print(f"Processed JSON result: {output.json_dict}")
+    elif output.output_format == "Pydantic":
+        print(f"Processed Pydantic result: {output.pydantic}")
+
+# 4. Create specialized agents
+async_agent = Agent(
+    name="AsyncSearchAgent",
+    role="Asynchronous Search Specialist",
+    goal="Perform fast and efficient asynchronous searches with structured results",
+    backstory="Expert in parallel search operations and data retrieval",
+    tools=[async_search_tool],
+    self_reflect=False,
+    verbose=True,
+    markdown=True
+)
+
+summary_agent = Agent(
+    name="SummaryAgent",
+    role="Research Synthesizer",
+    goal="Create comprehensive summaries and identify patterns across multiple search results",
+    backstory="""Expert in analyzing and synthesizing information from multiple sources.
+Skilled at identifying patterns, trends, and connections between different topics.
+Specializes in creating clear, structured summaries that highlight key insights.""",
+    self_reflect=True,  # Enable self-reflection for better summary quality
+    verbose=True,
+    markdown=True
+)
+
+# 5. Create async tasks
+async_task = Task(
+    name="async_search",
+    description="""Search for 'Async programming' and return results in the following JSON format:
+{
+    "query": "the search query",
+    "results": [
+        {
+            "title": "result title",
+            "url": "result url",
+            "snippet": "result snippet"
+        }
+    ],
+    "total_results": number of results
+}""",
+    expected_output="SearchResult model with query details and results",
+    agent=async_agent,
+    async_execution=True,
+    callback=async_callback,
+    output_json=SearchResult
+)
+
+# 6. Example usage functions
+async def run_single_task():
+    """Run single async task"""
+    print("\nRunning Single Async Task...")
+    agents = PraisonAIAgents(
+        agents=[async_agent],
+        tasks=[async_task],
+        verbose=1,
+        process="sequential"
+    )
+    result = await agents.astart()
+    print(f"Single Task Result: {result}")
+
+async def run_parallel_tasks():
+    """Run multiple async tasks in parallel"""
+    print("\nRunning Parallel Async Tasks...")
+    
+    # Define different search topics
+    search_topics = [
+        "Latest AI Developments 2024",
+        "Machine Learning Best Practices",
+        "Neural Networks Architecture"
+    ]
+    
+    # Create tasks for different topics
+    parallel_tasks = [
+        Task(
+            name=f"search_task_{i}",
+            description=f"""Search for '{topic}' and return results in the following JSON format:
+{{
+    "query": "{topic}",
+    "results": [
+        {{
+            "title": "result title",
+            "url": "result url",
+            "snippet": "result snippet"
+        }}
+    ],
+    "total_results": number of results
+}}""",
+            expected_output="SearchResult model with detailed information",
+            agent=async_agent,
+            async_execution=True,
+            callback=async_callback,
+            output_json=SearchResult
+        ) for i, topic in enumerate(search_topics)
+    ]
+    
+    # Create summarization task with the specialized summary agent
+    summary_task = Task(
+        name="summary_task",
+        description="""As a Research Synthesizer, analyze the search results and create a comprehensive summary. Your task:
+
+1. Analyze Results:
+   - Review all search results thoroughly
+   - Extract key findings from each topic
+   - Identify main themes and concepts
+
+2. Find Connections:
+   - Identify relationships between topics
+   - Spot common patterns or contradictions
+   - Note emerging trends across sources
+
+3. Create Structured Summary:
+   - Main findings per topic
+   - Cross-cutting themes
+   - Emerging trends
+   - Practical implications
+   - Future directions
+
+4. Quality Checks:
+   - Ensure all topics are covered
+   - Verify accuracy of connections
+   - Confirm clarity of insights
+   - Validate practical relevance
+
+Present the summary in a clear, structured format with sections for findings, patterns, trends, and implications.""",
+        expected_output="""A comprehensive research synthesis containing:
+- Detailed findings from each search topic
+- Cross-topic patterns and relationships
+- Emerging trends and their implications
+- Practical applications and future directions""",
+        agent=summary_agent,  # Use the specialized summary agent
+        async_execution=False,  # Run synchronously after search tasks
+        callback=async_callback
+    )
+    
+    # First run parallel search tasks
+    agents = PraisonAIAgents(
+        agents=[async_agent],
+        tasks=parallel_tasks,  # Only run search tasks first
+        verbose=1,
+        process="sequential"
+    )
+    search_results = await agents.astart()
+    print(f"Search Tasks Results: {search_results}")
+    
+    # Create task objects with results for context
+    completed_tasks = []
+    for i, topic in enumerate(search_topics):
+        task = Task(
+            name=f"search_task_{i}_result",
+            description=f"Search results for: {topic}",
+            expected_output="Search results from previous task",
+            agent=async_agent,
+            result=search_results["task_results"][i]
+        )
+        completed_tasks.append(task)
+    
+    # Update summary task with context from search results
+    summary_task.context = completed_tasks
+    
+    # Run summarization task with summary agent
+    summary_agents = PraisonAIAgents(
+        agents=[summary_agent],  # Use summary agent for synthesis
+        tasks=[summary_task],
+        verbose=1,
+        process="sequential"
+    )
+    summary_result = await summary_agents.astart()
+    print(f"Summary Task Result: {summary_result}")
+    
+    # Return results in a serializable format
+    return {
+        "search_results": {
+            "task_status": search_results["task_status"],
+            "task_results": [str(result) if result else None for result in search_results["task_results"]]
+        },
+        "summary": str(summary_result),
+        "topics": search_topics
+    }
+
+# 7. Main execution
+async def main():
+    """Main execution function"""
+    print("Starting Async AI Agents Examples...")
+    
+    try:
+        # Run different async patterns
+        await run_single_task()
+        await run_parallel_tasks()
+    except Exception as e:
+        print(f"Error in main execution: {e}")
+
+if __name__ == "__main__":
+    # Run the main function
+    asyncio.run(main())

agents/auto_agents_example.py

@@ -0,0 +1,11 @@
+from praisonaiagents import AutoAgents
+from praisonaiagents.tools import duckduckgo
+
+agents = AutoAgents(
+    instructions="Search for information about AI Agents",
+    tools=[duckduckgo],
+    process="sequential",
+    verbose=True
+)
+
+agents.start()

agents/autonomous-agent.py

@@ -0,0 +1,59 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_environment_feedback():
+    """Simulates environment feedback based on time"""
+    current_time = int(time.time())
+    feedback = "positive" if current_time % 2 == 0 else "negative"
+    print(f"Environment feedback: {feedback}")
+    return feedback
+
+# Create autonomous agent
+autonomous_agent = Agent(
+    name="Autonomous Agent",
+    role="Environment interactor",
+    goal="Interact with environment and learn from feedback",
+    instructions="Take actions based on environment state and adapt from feedback",
+    tools=[get_environment_feedback]
+)
+
+# Create tasks for the autonomous loop
+action_task = Task(
+    name="take_action",
+    description="Analyze environment and take appropriate action",
+    expected_output="Action taken and its rationale",
+    agent=autonomous_agent,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["process_feedback"],
+    condition={
+        "continue": ["process_feedback"],  # Continue to get feedback
+        "stop": [""]  # Stop when goal is achieved
+    }
+)
+
+feedback_task = Task(
+    name="process_feedback",
+    description="Process environment feedback and adapt strategy",
+    expected_output="Adapted strategy based on feedback",
+    agent=autonomous_agent,
+    next_tasks=["take_action"],
+    context=[action_task]  # Access to previous action for learning
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[autonomous_agent],
+    tasks=[action_task, feedback_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run autonomous workflow
+results = workflow.start()
+
+# Print results
+print("\nAutonomous Agent Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/code_agents_example.py

@@ -0,0 +1,50 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import json
+from e2b_code_interpreter import Sandbox
+
+def code_interpreter(code: str):
+    """
+    A function to demonstrate running Python code dynamically using e2b_code_interpreter.
+    """
+    print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
+    exec_result = Sandbox().run_code(code)
+    if exec_result.error:
+        print("[Code Interpreter error]", exec_result.error)
+        return {"error": str(exec_result.error)}
+    else:
+        results = []
+        for result in exec_result.results:
+            if hasattr(result, '__iter__'):
+                results.extend(list(result))
+            else:
+                results.append(str(result))
+        logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
+        return json.dumps({"results": results, "logs": logs})
+
+code_agent = Agent(
+    name="code_agent",
+    llm="gpt-4o-mini",
+    backstory="Expert in writing Python scripts",
+    self_reflect=False
+)
+execution_agent = Agent(
+    name="execution_agent",
+    llm="gpt-4o-mini",
+    backstory="Expert in executing Python scripts",
+    self_reflect=False,
+    tools=[code_interpreter]
+)
+
+code_agent_task = Task(
+    description="Write a simple Python script to print 'Hello, World!'",
+    expected_output="A Python script that prints 'Hello, World!'",
+    agent=code_agent
+)
+execution_agent_task = Task(
+    description="Execute the Python script",
+    expected_output="The output of the Python script",
+    agent=execution_agent
+)
+
+agents = PraisonAIAgents(agents=[code_agent, execution_agent], tasks=[code_agent_task, execution_agent_task])
+agents.start()

agents/evaluator-optimiser.py

@@ -0,0 +1,70 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create generator and evaluator agents
+generator = Agent(
+    name="Generator",
+    role="Solution generator",
+    goal="Generate initial solutions and incorporate feedback",
+    instructions=(
+        "1. Look at the context from previous tasks.\n"
+        "2. If you see that you have already produced 2 points, then add another 2 new points "
+        "   so that the total becomes 10.\n"
+        "3. Otherwise, just produce the first 2 points.\n"
+        "4. Return only the final list of points, with no extra explanation."
+    )
+)
+
+evaluator = Agent(
+    name="Evaluator",
+    role="Solution evaluator",
+    goal="Evaluate solutions and provide improvement feedback",
+    instructions=(
+        "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
+        "2. If there are 10 or more, respond with 'done'.\n"
+        "3. Otherwise, respond with 'more'.\n"
+        "4. Return only the single word: 'done' or 'more'."
+    )
+)
+
+
+# Create tasks for the feedback loop
+generate_task = Task(
+    name="generate",
+    description="Write 2 points about AI incuding if anything exiting from previous points",
+    expected_output="2 points",
+    agent=generator,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["evaluate"]
+)
+
+evaluate_task = Task(
+    name="evaluate",
+    description="Check if there are 10 points about AI",
+    expected_output="more or done",
+    agent=evaluator,
+    next_tasks=["generate"],
+    context=[generate_task],
+    task_type="decision",
+    condition={
+        "more": ["generate"],  # Continue to generate
+        "done": [""]  # Exit when optimization complete
+    }
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[generator, evaluator],
+    tasks=[generate_task, evaluate_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run optimization workflow
+results = workflow.start()
+
+# Print results
+print("\nEvaluator-Optimizer Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/example_callback.py

@@ -0,0 +1,204 @@
+from praisonaiagents import (
+    Agent, 
+    Task, 
+    PraisonAIAgents, 
+    error_logs, 
+    register_display_callback,
+    sync_display_callbacks,
+    async_display_callbacks
+)
+from duckduckgo_search import DDGS
+from rich.console import Console
+import json
+from datetime import datetime
+import logging
+
+# Setup logging
+logging.basicConfig(
+    filename='ai_interactions.log',
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+# Callback functions for different display types
+def interaction_callback(message=None, response=None, markdown=None, generation_time=None):
+    """Callback for display_interaction"""
+    logging.info(f"""
+    === INTERACTION ===
+    Time: {datetime.now()}
+    Generation Time: {generation_time}s
+    Message: {message}
+    Response: {response}
+    Markdown: {markdown}
+    """)
+
+def error_callback(message=None):
+    """Callback for display_error"""
+    logging.error(f"""
+    === ERROR ===
+    Time: {datetime.now()}
+    Message: {message}
+    """)
+
+def tool_call_callback(message=None):
+    """Callback for display_tool_call"""
+    logging.info(f"""
+    === TOOL CALL ===
+    Time: {datetime.now()}
+    Message: {message}
+    """)
+
+def instruction_callback(message=None):
+    """Callback for display_instruction"""
+    logging.info(f"""
+    === INSTRUCTION ===
+    Time: {datetime.now()}
+    Message: {message}
+    """)
+
+def self_reflection_callback(message=None):
+    """Callback for display_self_reflection"""
+    logging.info(f"""
+    === SELF REFLECTION ===
+    Time: {datetime.now()}
+    Message: {message}
+    """)
+
+def generating_callback(content=None, elapsed_time=None):
+    """Callback for display_generating"""
+    logging.info(f"""
+    === GENERATING ===
+    Time: {datetime.now()}
+    Content: {content}
+    Elapsed Time: {elapsed_time}
+    """)
+
+# Register all callbacks
+register_display_callback('interaction', interaction_callback)
+register_display_callback('error', error_callback)
+register_display_callback('tool_call', tool_call_callback)
+register_display_callback('instruction', instruction_callback)
+register_display_callback('self_reflection', self_reflection_callback)
+# register_display_callback('generating', generating_callback)
+
+def task_callback(output):
+    """Callback for task completion"""
+    logging.info(f"""
+    === TASK COMPLETED ===
+    Time: {datetime.now()}
+    Description: {output.description}
+    Agent: {output.agent}
+    Output: {output.raw[:200]}...
+    """)
+
+def internet_search_tool(query) -> list:
+    """
+    Perform a search using DuckDuckGo.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        list: A list of search result titles and URLs.
+    """
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=10):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+
+    except Exception as e:
+        print(f"Error during DuckDuckGo search: {e}")
+        return []
+
+def main():
+    # Create agents
+    researcher = Agent(
+        name="Researcher",
+        role="Senior Research Analyst",
+        goal="Uncover cutting-edge developments in AI and data science",
+        backstory="""You are an expert at a technology research group, 
+        skilled in identifying trends and analyzing complex data.""",
+        verbose=True,
+        allow_delegation=False,
+        tools=[internet_search_tool],
+        llm="gpt-4o",
+        markdown=True,
+        reflect_llm="gpt-4o",
+        min_reflect=2,
+        max_reflect=4
+    )
+    
+    writer = Agent(
+        name="Writer",
+        role="Tech Content Strategist",
+        goal="Craft compelling content on tech advancements",
+        backstory="""You are a content strategist known for 
+        making complex tech topics interesting and easy to understand.""",
+        verbose=True,
+        allow_delegation=True,
+        llm="gpt-4o",
+        tools=[],
+        markdown=True
+    )
+
+    # Create tasks with callbacks
+    task1 = Task(
+        name="research_task",
+        description="""Analyze 2024's AI advancements. 
+        Find major trends, new technologies, and their effects.""",
+        expected_output="""A detailed report on 2024 AI advancements""",
+        agent=researcher,
+        tools=[internet_search_tool],
+        callback=task_callback
+    )
+
+    task2 = Task(
+        name="writing_task",
+        description="""Create a blog post about major AI advancements using the insights you have.
+        Make it interesting, clear, and suited for tech enthusiasts. 
+        It should be at least 4 paragraphs long.""",
+        expected_output="A blog post of at least 4 paragraphs",
+        agent=writer,
+        context=[task1],
+        callback=task_callback,
+        tools=[]
+    )
+
+    task3 = Task(
+        name="json_task",
+        description="""Create a json object with a title of "My Task" and content of "My content".""",
+        expected_output="""JSON output with title and content""",
+        agent=researcher,
+        callback=task_callback
+    )
+
+    task4 = Task(
+        name="save_output_task",
+        description="""Save the AI blog post to a file""",
+        expected_output="""File saved successfully""",
+        agent=writer,
+        context=[task2],
+        output_file='test.txt',
+        create_directory=True,
+        callback=task_callback
+    )
+
+    # Create and run agents manager
+    agents = PraisonAIAgents(
+        agents=[researcher, writer],
+        tasks=[task1, task2, task3, task4],
+        verbose=True,
+        process="sequential",
+        manager_llm="gpt-4o"
+    )
+
+    agents.start()
+
+if __name__ == "__main__":
+    main()

agents/example_custom_tools.py

@@ -0,0 +1,151 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from typing import List, Dict, Union
+from duckduckgo_search import DDGS
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.utilities import WikipediaAPIWrapper
+
+# 1. Tool
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform a search using DuckDuckGo.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        list: A list of search result titles, URLs, and snippets.
+    """
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=10):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+
+    except Exception as e:
+        print(f"Error during DuckDuckGo search: {e}")
+        return []
+    
+def youtube_search_tool(query: str, inspect: bool = False, max_results: int = 2):
+    """
+    Provide a custom wrapper around the YouTubeSearchTool.
+    
+    Args:
+        query (str): The search query for YouTube.
+        inspect (bool): If True, returns tool inspection info instead of search results.
+        max_results (int): Maximum number of results to return (default: 2).
+    Returns:
+        Union[List[str], dict]: List of YouTube video URLs or tool inspection info.
+    """
+    yt = YouTubeSearchTool()
+    
+    if inspect:
+        inspection_info = {
+            "type": type(yt),
+            "attributes": [attr for attr in dir(yt) if not attr.startswith('_')],
+            "methods": {
+                "run": getattr(yt, 'run', None),
+                "arun": getattr(yt, 'arun', None)
+            },
+            "properties": {
+                "name": getattr(yt, 'name', 'youtube_search'),
+                "description": getattr(yt, 'description', 'Search YouTube videos'),
+                "return_direct": getattr(yt, 'return_direct', False)
+            }
+        }
+        return inspection_info
+    
+    # Format query with max_results
+    formatted_query = f"{query}, {max_results}"
+    return yt.run(formatted_query)
+
+def wikipedia_search_tool(query: str, inspect: bool = False, max_chars: int = 4000, top_k: int = 3):
+    """
+    Provide a custom wrapper around langchain_community's WikipediaAPIWrapper.
+
+    Args:
+        query (str): A search query for Wikipedia.
+        inspect (bool): If True, returns tool inspection info instead of search results.
+        max_chars (int): Maximum characters to return (default: 4000).
+        top_k (int): Number of top results to consider (default: 3).
+    Returns:
+        Union[str, dict]: Summary from Wikipedia or tool inspection info if inspect=True.
+    """
+    w = WikipediaAPIWrapper(
+        top_k_results=top_k,
+        doc_content_chars_max=max_chars,
+        lang='en'
+    )
+    
+    if inspect:
+        inspection_info = {
+            "type": type(w),
+            "attributes": [attr for attr in dir(w) if not attr.startswith('_')],
+            "methods": {
+                "run": getattr(w, 'run', None),
+                "arun": getattr(w, 'arun', None)
+            },
+            "properties": {
+                "name": "wikipedia",
+                "description": "Search and get summaries from Wikipedia",
+                "top_k": w.top_k_results,
+                "lang": w.lang,
+                "max_chars": w.doc_content_chars_max
+            }
+        }
+        return inspection_info
+    
+    try:
+        result = w.run(query)
+        return result
+    except Exception as e:
+        return f"Error searching Wikipedia: {str(e)}"
+
+# 2. Agent
+data_agent = Agent(
+    name="DataCollector",
+    role="Search Specialist",
+    goal="Perform internet searches to collect relevant information.",
+    backstory="Expert in finding and organizing internet data from multiple sources.",
+    tools=[internet_search_tool, youtube_search_tool, wikipedia_search_tool],
+    self_reflect=False
+)
+
+# 3. Tasks
+collect_task = Task(
+    description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
+    expected_output="List of search results with titles, URLs, and snippets.",
+    agent=data_agent,
+    name="collect_data",
+    is_start=True,
+    next_tasks=["validate_data"]
+)
+
+validate_task = Task(
+    description="""Validate the collected data. Check if:
+    1. At least 5 results are returned.
+    2. Each result contains a title and a URL.
+    Return validation_result as 'valid' or 'invalid' only no other text.""",
+    expected_output="Validation result indicating if data is valid or invalid.",
+    agent=data_agent,
+    name="validate_data",
+    task_type="decision",
+    condition={
+        "valid": [],  # End the workflow on valid data
+        "invalid": ["collect_data"]  # Retry data collection on invalid data
+    },
+)
+
+# 4. Workflow
+agents = PraisonAIAgents(
+    agents=[data_agent],
+    tasks=[collect_task, validate_task],
+    verbose=1,
+    process="workflow"
+)
+
+agents.start()

agents/example_sequential.py

@@ -0,0 +1,141 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents, error_logs
+from duckduckgo_search import DDGS
+
+def my_callback(output):
+    print(f"Callback Task output: {output}")
+
+def internet_search_tool(query) -> list:
+    """
+    Perform a search using DuckDuckGo.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        list: A list of search result titles and URLs.
+    """
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=10):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+
+    except Exception as e:
+        print(f"Error during DuckDuckGo search: {e}")
+        return []
+
+# Create agents
+researcher = Agent(
+    name="Researcher",
+    role="Senior Research Analyst",
+    goal="Uncover cutting-edge developments in AI and data science",
+    backstory="""You are an expert at a technology research group, 
+    skilled in identifying trends and analyzing complex data.""",
+    verbose=True,
+    allow_delegation=False,
+    tools=[internet_search_tool],
+    llm="gpt-4o",
+    markdown=True,
+    reflect_llm="gpt-4o",
+    min_reflect=2,
+    max_reflect=4
+)
+writer = Agent(
+    name="Writer",
+    role="Tech Content Strategist",
+    goal="Craft compelling content on tech advancements",
+    backstory="""You are a content strategist known for 
+    making complex tech topics interesting and easy to understand.""",
+    verbose=True,
+    allow_delegation=True,
+    llm="gpt-4o",
+    tools=[],
+    markdown=True
+)
+
+# Create tasks
+task1 = Task(
+    name="research_task",
+    description="""Analyze 2024's AI advancements. 
+    Find major trends, new technologies, and their effects.""",
+    expected_output="""A detailed report on 2024 AI advancements""",
+    agent=researcher,
+    tools=[internet_search_tool]
+)
+
+task2 = Task(
+    name="writing_task",
+    description="""Create a blog post about major AI advancements using the insights you have.
+    Make it interesting, clear, and suited for tech enthusiasts. 
+    It should be at least 4 paragraphs long. 
+    Also, call the get_weather tool to get the weather in Paris.""",
+    expected_output="A blog post of at least 4 paragraphs, and weather in Paris",
+    agent=writer,
+    context=[task1],
+    callback=my_callback,
+    tools=[]
+)
+
+task3 = Task(
+    name="json_task",
+    description="""Create a json object with a title of "My Task" and content of "My content".""",
+    expected_output="""JSON output with title and content""",
+    agent=researcher,
+)
+
+task4 = Task(
+    name="save_output_task",
+    description="""Save the AI blog post to a file""",
+    expected_output="""File saved successfully""",
+    agent=writer,
+    context=[task2],
+    output_file='outputs/ai_blog_post.txt',
+    create_directory=True
+)
+
+# Create and run agents manager
+agents = PraisonAIAgents(
+    agents=[researcher, writer],
+    tasks=[task1, task2, task3, task4],
+    verbose=False,
+    process="sequential",  # "sequential" or "hierarchical"
+    manager_llm="gpt-4o"
+)
+
+result = agents.start()
+
+# Print results and error summary
+print("\n=== Task Results ===")
+for task_id, task_status in result['task_status'].items():
+    print(f"Task {task_id}: {task_status}")
+    if task_result := result['task_results'].get(task_id):
+        print(f"Output: {task_result.raw[:200]}...")  # Show first 200 chars
+
+# Print task details
+print("\n=== Task Details ===")
+for i in range(4):
+    print(agents.get_task_details(i))
+
+# Print agent details
+print("\n=== Agent Details ===")
+print(agents.get_agent_details('Researcher'))
+print(agents.get_agent_details('Writer'))
+
+# Print any errors
+if error_logs:
+    print("\n=== Error Summary ===")
+    for err in error_logs:
+        print(f"- {err}")
+        if "parsing self-reflection json" in err:
+            print("  Reason: The self-reflection JSON response was not valid JSON.")
+        elif "Error: Task with ID" in err:
+            print("  Reason: Task ID referenced does not exist.")
+        elif "saving task output to file" in err:
+            print("  Reason: Possible file permissions or invalid path.")
+        else:
+            print("  Reason not identified")

agents/langchain_example.py

@@ -0,0 +1,30 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.utilities import WikipediaAPIWrapper
+
+# Create an agent with both tools
+agent = Agent(
+    name="SearchAgent",
+    role="Research Assistant",
+    goal="Search for information from multiple sources",
+    backstory="I am an AI assistant that can search YouTube and Wikipedia.",
+    tools=[YouTubeSearchTool, WikipediaAPIWrapper],
+    self_reflect=False
+)
+
+# Create tasks to demonstrate both tools
+task = Task(
+    name="search_task",
+    description="Search for information about 'AI advancements' on both YouTube and Wikipedia",
+    expected_output="Combined information from YouTube videos and Wikipedia articles",
+    agent=agent
+)
+
+# Create and start the workflow
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    verbose=True
+)
+
+agents.start()

agents/langchain_logs.py

@@ -0,0 +1,73 @@
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.utilities import WikipediaAPIWrapper
+
+def test_tools():
+    """Test both YouTube and Wikipedia tools"""
+    
+    print("\n=== Testing YouTube Search ===")
+    # Test YouTube
+    yt = YouTubeSearchTool()
+    
+    # Test basic search
+    print("\nBasic YouTube Search:")
+    query = "AI advancements 2024"
+    print(f"Query: {query}")
+    result = yt.run(query)
+    print(f"Results: {result}")
+    
+    # Test with max results
+    print("\nYouTube Search with max results:")
+    query = "AI advancements 2024, 3"  # Format: query, max_results
+    print(f"Query: {query}")
+    result = yt.run(query)
+    print(f"Results: {result}")
+    
+    print("\n=== Testing Wikipedia Search ===")
+    # Test Wikipedia
+    wiki = WikipediaAPIWrapper(
+        top_k_results=2,
+        doc_content_chars_max=500
+    )
+    
+    # Test basic search
+    print("\nBasic Wikipedia Search:")
+    query = "Artificial Intelligence"
+    print(f"Query: {query}")
+    result = wiki.run(query)
+    print(f"Results: {result[:200]}..." if result else "No result")
+    
+    # Test with different parameters
+    print("\nWikipedia Search with different language:")
+    wiki_fr = WikipediaAPIWrapper(
+        lang='fr',
+        top_k_results=1,
+        doc_content_chars_max=300
+    )
+    result = wiki_fr.run("Intelligence Artificielle")
+    print(f"French Results: {result[:200]}..." if result else "No result")
+
+def print_tool_info():
+    """Print detailed information about the tools"""
+    
+    print("\n=== Tool Information ===")
+    
+    # YouTube Tool Info
+    print("\nYouTube Tool:")
+    yt = YouTubeSearchTool()
+    print("Type:", type(yt))
+    print("Name:", getattr(yt, 'name', None))
+    print("Description:", getattr(yt, 'description', None))
+    print("Arguments:", getattr(yt, 'args', None))
+    
+    # Wikipedia Tool Info
+    print("\nWikipedia Tool:")
+    wiki = WikipediaAPIWrapper()
+    print("Type:", type(wiki))
+    print("Available Settings:")
+    print("- Language:", wiki.lang)
+    print("- Top K Results:", wiki.top_k_results)
+    print("- Max Characters:", wiki.doc_content_chars_max)
+
+if __name__ == "__main__":
+    print_tool_info()
+    test_tools() 

agents/memory_example.py

@@ -0,0 +1,183 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import logging
+import os
+
+def main():
+    # Initialize memory config
+    memory_config = {
+        "provider": "rag",
+        "use_embedding": True,
+        "storage": {
+            "type": "sqlite",
+            "path": "./.praison/memory.db"
+        },
+        "rag_db_path": "./.praison/chroma_db"
+    }
+    
+    # Test facts
+    fact1 = "The capital city of Jujuha is Hahanu and its population is 102300"
+    fact2 = "Three main ingredients in a classic proloder are eggs, sugar, and flour"
+    fact3 = "The year the first Josinga was released is 2007"
+    
+    # # Check if database exists
+    # if os.path.exists("./memory.db"):
+    #     logger.info("Found existing memory database")
+    # else:
+    #     logger.info("Creating new memory database")
+    
+    # Create task config (without memory config since it's moved to PraisonAIAgents)
+    task_config = {}
+
+    # Create agents with different roles
+    researcher = Agent(
+        role="Research Analyst",
+        goal="Research and document key information about topics",
+        backstory="Expert at analyzing and storing information in memory",
+        llm="gpt-4o-mini"
+    )
+    
+    retriever = Agent(
+        role="Information Retriever",
+        goal="Retrieve and verify stored information from memory",
+        backstory="Specialist in searching and validating information from memory",
+        llm="gpt-4o-mini"
+    )
+
+    # Task 1: Process the facts
+    store_task = Task(
+        description=f"""
+        Process and analyze this information:
+        1. {fact1}
+        2. {fact2}
+        3. {fact3}
+
+        Provide a clear summary of each fact.
+        """,
+        expected_output="""
+        Clear statements summarizing each fact.
+        Example format:
+        1. [Summary of fact 1]
+        2. [Summary of fact 2]
+        3. [Summary of fact 3]
+        """,
+        agent=researcher
+    )
+
+    # Task 2: Write essay about AI
+    verify_task = Task(
+        description="""
+        write few points about AI
+        """,
+        expected_output="Points about AI",
+        agent=retriever
+    )
+
+    # Task 3: Query memory
+    query_task = Task(
+        description="""
+        Using ONLY information found in memory:
+        1. What is stored in memory about Hahanu?
+        2. What ingredients for proloder are recorded in memory?
+        3. What year is stored in memory for the Josinga release?
+
+        For each answer, cite the memory record you found.
+        """,
+        expected_output="Answers based solely on memory records with citations",
+        agent=retriever
+    )
+
+    # Task 4: Query both short-term and long-term memory
+    query_both_task = Task(
+        description="""
+        Using ONLY information found in memory:
+        1. What is stored in both short-term and long-term memory about Jujuha?
+        2. What ingredients for proloder are recorded in both short-term and long-term memory?
+        3. What year is stored in both short-term and long-term memory for the Josinga release?
+
+        For each answer, cite the memory record you found.
+        """,
+        expected_output="Answers based solely on memory records with citations",
+        agent=retriever
+    )
+
+    # Initialize PraisonAIAgents with memory configuration
+    agents = PraisonAIAgents(
+        agents=[researcher, retriever],
+        tasks=[store_task, verify_task, query_task, query_both_task],
+        verbose=True,  # Use same verbose level as memory
+        memory=True,
+        embedder={
+            "provider": "openai",
+            "config": {
+                "model": "text-embedding-3-small"
+            }
+        }
+    )
+
+    # agents = PraisonAIAgents(
+    #     agents=[researcher, retriever],
+    #     tasks=[store_task, verify_task, query_task, query_both_task],
+    #     verbose=True,  # Use same verbose level as memory
+    #     memory=True
+    # )
+    
+    # Execute tasks
+    print("\nExecuting Memory Test Tasks...")
+    print("-" * 50)
+    agents.start()
+    
+    # Use shared memory for final checks
+    memory = agents.shared_memory
+    
+    # Test memory retrieval with different quality thresholds
+    if memory:
+        print("\nFinal Memory Check:")
+        print("-" * 50)
+        
+        queries = ["Jujuha", "proloder", "Josinga"]
+        for query in queries:
+            print(f"\nSearching memory for: {query}")
+            
+            # Search in both short-term and long-term memory
+            print("\nShort-term memory results:")
+            stm_results = memory.search_short_term(query)
+            if stm_results:
+                for item in stm_results:
+                    print(f"Content: {item.get('content', '')[:200]}")
+                    if 'meta' in item:
+                        print(f"Metadata: {item['meta']}")
+                    print("-" * 20)
+            else:
+                print("No results found in short-term memory")
+
+            print("\nLong-term memory results:")
+            ltm_results = memory.search_long_term(query)
+            if ltm_results:
+                for item in ltm_results:
+                    print(f"Content: {item.get('text', '')[:200]}")
+                    if 'metadata' in item:
+                        print(f"Metadata: {item['metadata']}")
+                    print("-" * 20)
+            else:
+                print("No results found in long-term memory")
+                
+            # Also check ChromaDB if using RAG
+            if memory.use_rag and hasattr(memory, "chroma_col"):
+                print("\nChromaDB results:")
+                try:
+                    all_items = memory.chroma_col.get()
+                    print(f"Found {len(all_items['ids'])} items in ChromaDB")
+                    for i in range(len(all_items['ids'])):
+                        print(f"ID: {all_items['ids'][i]}")
+                        print(f"Content: {all_items['documents'][i][:200]}")
+                        print(f"Metadata: {all_items['metadatas'][i]}")
+                        print("-" * 20)
+                except Exception as e:
+                    print(f"Error querying ChromaDB: {e}")
+            
+            print("-" * 30)
+    else:
+        print("\nNo memory available for final checks")
+
+if __name__ == "__main__":
+    main()

agents/memory_simple.py

@@ -0,0 +1,63 @@
+from praisonaiagents.agents.agents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+
+# Test facts
+fact1 = "The capital city of Jujuha is Hahanu and its population is 102300"
+fact2 = "Three main ingredients in a classic proloder are eggs, sugar, and flour"
+fact3 = "The year the first Josinga was released is 2007"
+
+fact_agent = Agent(
+    name="Fact Agent",
+    instructions="You are a fact agent, you store and retrieve facts in memory",
+    llm="gpt-4o-mini"
+)
+
+research_agent = Agent(
+    name="Research Agent",
+    instructions="You are a research analyst, you research and document key points about topics",
+    llm="gpt-4o-mini"
+)
+
+blog_agent = Agent(
+    name="Blog Agent",
+    instructions="You are a blog writer, you write a blog post about the research",
+    llm="gpt-4o-mini"
+)
+
+fact_task = Task(
+    description="Store the following facts in memory: " + fact1 + ", " + fact2 + ", " + fact3,
+    agent=fact_agent
+)
+
+research_task = Task(
+    description="Research and document 2 key points about AI",
+    agent=research_agent
+)
+
+research_task2 = Task(
+    description="Research and document 2 key points about AI in healthcare",
+    agent=research_agent
+)
+
+research_task3 = Task(
+    description="Research and document 2 key points about AI in education",
+    agent=research_agent
+)
+
+research_task4 = Task(
+    description="Research and document 2 key points about AI in finance",
+    agent=research_agent
+)
+
+blog_task = Task(
+    description="Write a blog post about Jujuha",
+    agent=blog_agent
+)
+
+agents = PraisonAIAgents(
+    agents=[fact_agent, research_agent, blog_agent],
+    tasks=[fact_task, research_task, research_task2, research_task3, research_task4, blog_task],
+    memory=True
+)   
+
+agents.start()

agents/mini_agents_example.py

@@ -0,0 +1,6 @@
+from praisonaiagents import Agent, Agents, Tools
+
+research_agent = Agent(instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+summarise_agent = Agent(instructions="You are a summarize agent to summarise in points")
+agents = Agents(agents=[research_agent, summarise_agent])
+agents.start()

agents/multimodal.py

@@ -0,0 +1,59 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create Vision Analysis Agent
+vision_agent = Agent(
+    name="VisionAnalyst",
+    role="Computer Vision Specialist",
+    goal="Analyze images and videos to extract meaningful information",
+    backstory="""You are an expert in computer vision and image analysis.
+    You excel at describing images, detecting objects, and understanding visual content.""",
+    llm="gpt-4o-mini",
+    self_reflect=False
+)
+
+# 1. Task with Image URL
+task1 = Task(
+    name="analyze_landmark",
+    description="Describe this famous landmark and its architectural features.",
+    expected_output="Detailed description of the landmark's architecture and significance",
+    agent=vision_agent,
+    images=["https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg"]
+)
+
+# 2. Task with Local Image File
+task2 = Task(
+    name="analyze_local_image",
+    description="What objects can you see in this image? Describe their arrangement.",
+    expected_output="Detailed description of objects and their spatial relationships",
+    agent=vision_agent,
+    images=["image.jpg"] 
+)
+
+# 3. Task with Video File
+task3 = Task(
+    name="analyze_video",
+    description="""Watch this video and provide:
+    1. A summary of the main events
+    2. Key objects and people visible
+    3. Any text or important information shown
+    4. The overall context and setting""",
+    expected_output="Comprehensive analysis of the video content",
+    agent=vision_agent,
+    images=["video.mp4"]  
+)
+
+# Create PraisonAIAgents instance
+agents = PraisonAIAgents(
+    agents=[vision_agent],
+    tasks=[task1, task2, task3],
+    process="sequential",
+    verbose=1
+)
+
+# Run all tasks
+result = agents.start()
+
+# Print results
+for task_id, task_result in result["task_results"].items():
+    print(f"\nTask {task_id} Result:")
+    print(task_result.raw)

agents/orchestrator-workers.py

@@ -0,0 +1,110 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_time_check():
+    current_time = int(time.time())
+    if current_time % 3 == 0:
+        result = 1
+    elif current_time % 3 == 1:
+        result = 2
+    else:
+        result = 3
+    print(f"Time: {current_time}, Result: {result}")
+    return result
+
+# Create orchestrator and worker agents
+router = Agent(
+    name="Router",
+    role="Task router",
+    goal="Distribute tasks to based on response from get_time_check",
+    tools=[get_time_check]
+)
+
+worker1 = Agent(
+    name="Worker 1",
+    role="Specialized worker",
+    goal="Handle specific subtask type 1",
+)
+
+worker2 = Agent(
+    name="Worker 2",
+    role="Specialized worker",
+    goal="Handle specific subtask type 2",
+)
+
+worker3 = Agent(
+    name="Worker 3",
+    role="Specialized worker",
+    goal="Handle specific subtask type 3",
+)
+
+synthesizer = Agent(
+    name="Synthesizer",
+    role="Result synthesizer",
+    goal="Combine and synthesize worker outputs",
+)
+
+# Create orchestrated workflow tasks
+router_task = Task(
+    name="route_task",
+    description="Analyze input from get_time_check and route to appropriate workers",
+    expected_output="Task routing decision, 1 , 2 or 3",
+    agent=router,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["worker1_task", "worker2_task", "worker3_task"],
+    condition={
+        "1": ["worker1_task"],
+        "2": ["worker2_task"],
+        "3": ["worker3_task"]
+    }
+)
+
+worker1_task = Task(
+    name="worker1_task",
+    description="Process type 1 operation",
+    expected_output="Worker 1 result",
+    agent=worker1,
+    next_tasks=["synthesize_task"]
+)
+
+worker2_task = Task(
+    name="worker2_task",
+    description="Process type 2 operation",
+    expected_output="Worker 2 result",
+    agent=worker2,
+    next_tasks=["synthesize_task"]
+)
+
+worker3_task = Task(
+    name="worker3_task",
+    description="Process type 3 operation",
+    expected_output="Worker 3 result",
+    agent=worker3,
+    next_tasks=["synthesize_task"]
+)
+
+synthesize_task = Task(
+    name="synthesize_task",
+    description="Synthesize worker results into final output",
+    expected_output="Final synthesized result",
+    agent=synthesizer,
+    context=[worker1_task, worker2_task, worker3_task]
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[router, worker1, worker2, worker3, synthesizer],
+    tasks=[router_task, worker1_task, worker2_task, worker3_task, synthesize_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run orchestrated workflow
+results = workflow.start()
+
+# Print results
+print("\nOrchestrator-Workers Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/parallelisation.py

@@ -0,0 +1,95 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from datetime import datetime
+import asyncio
+
+def process_time():
+    """Simulate processing"""
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"Processing at: {current_time}")
+    return f"Processed at {current_time}"
+
+# Create parallel processing agents
+agent1 = Agent(
+    name="Processor 1",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent2 = Agent(
+    name="Processor 2",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent3 = Agent(
+    name="Processor 3",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+aggregator = Agent(
+    name="Aggregator",
+    role="Result aggregator",
+    goal="Collect all the processed time from all tasks"
+)
+
+# Create parallel tasks with memory disabled
+task1 = Task(
+    name="process_1",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent1,
+    is_start=True,
+    async_execution=True
+)
+
+task2 = Task(
+    name="process_2",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent2,
+    is_start=True,
+    async_execution=True
+)
+
+task3 = Task(
+    name="process_3",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent3,
+    is_start=True,
+    async_execution=True
+)
+
+aggregate_task = Task(
+    name="aggregate",
+    description="Collect all the processed time from all tasks",
+    expected_output="Output all the processed time from all tasks and just the time",
+    agent=aggregator,
+    context=[task1, task2, task3]
+)
+
+async def main():
+
+    # Create workflow manager
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, agent3, aggregator],
+        tasks=[task1, task2, task3, aggregate_task],
+        process="workflow"
+    )
+
+    # Run parallel workflow
+    results = await workflow.astart()
+
+    # Print results
+    print("\nParallel Processing Results:")
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"Task {task_id}: {result.raw}")
+
+# Run the async main function
+if __name__ == "__main__":
+    asyncio.run(main())

agents/praisonaiagents/__init__.py

@@ -0,0 +1,51 @@
+"""
+Praison AI Agents - A package for hierarchical AI agent task execution
+"""
+
+from .agent.agent import Agent
+from .agents.agents import PraisonAIAgents
+from .task.task import Task
+from .tools.tools import Tools
+from .agents.autoagents import AutoAgents
+from .memory.memory import Memory
+from .main import (
+    TaskOutput,
+    ReflectionOutput,
+    display_interaction,
+    display_self_reflection,
+    display_instruction,
+    display_tool_call,
+    display_error,
+    display_generating,
+    clean_triple_backticks,
+    error_logs,
+    register_display_callback,
+    sync_display_callbacks,
+    async_display_callbacks,
+)
+
+# Add Agents as an alias for PraisonAIAgents
+Agents = PraisonAIAgents
+
+__all__ = [
+    'Agent',
+    'PraisonAIAgents',
+    'Agents',
+    'Tools',
+    'Task',
+    'TaskOutput',
+    'ReflectionOutput',
+    'AutoAgents',
+    'Memory',
+    'display_interaction',
+    'display_self_reflection',
+    'display_instruction',
+    'display_tool_call',
+    'display_error',
+    'display_generating',
+    'clean_triple_backticks',
+    'error_logs',
+    'register_display_callback',
+    'sync_display_callbacks',
+    'async_display_callbacks',
+] 

agents/praisonaiagents/agent/__init__.py

@@ -0,0 +1,4 @@
+"""Agent module for AI agents"""
+from .agent import Agent
+
+__all__ = ['Agent'] 

agents/praisonaiagents/agent/agent.py

@@ -0,0 +1,765 @@
+import os
+import time
+import json
+import logging
+import asyncio
+from typing import List, Optional, Any, Dict, Union, Literal, TYPE_CHECKING
+from rich.console import Console
+from rich.live import Live
+from openai import AsyncOpenAI
+from ..main import (
+    display_error,
+    display_tool_call,
+    display_instruction,
+    display_interaction,
+    display_generating,
+    display_self_reflection,
+    ReflectionOutput,
+    client,
+    error_logs,
+    adisplay_instruction
+)
+import inspect
+
+if TYPE_CHECKING:
+    from ..task.task import Task
+
+class Agent:
+    def _generate_tool_definition(self, function_name):
+        """
+        Generate a tool definition from a function name by inspecting the function.
+        """
+        logging.debug(f"Attempting to generate tool definition for: {function_name}")
+        
+        # First try to get the tool definition if it exists
+        tool_def_name = f"{function_name}_definition"
+        tool_def = globals().get(tool_def_name)
+        logging.debug(f"Looking for {tool_def_name} in globals: {tool_def is not None}")
+        
+        if not tool_def:
+            import __main__
+            tool_def = getattr(__main__, tool_def_name, None)
+            logging.debug(f"Looking for {tool_def_name} in __main__: {tool_def is not None}")
+        
+        if tool_def:
+            logging.debug(f"Found tool definition: {tool_def}")
+            return tool_def
+
+        # Try to find the function in the agent's tools list first
+        func = None
+        for tool in self.tools:
+            if callable(tool) and getattr(tool, '__name__', '') == function_name:
+                func = tool
+                break
+        
+        logging.debug(f"Looking for {function_name} in agent tools: {func is not None}")
+        
+        # If not found in tools, try globals and main
+        if not func:
+            func = globals().get(function_name)
+            logging.debug(f"Looking for {function_name} in globals: {func is not None}")
+            
+            if not func:
+                import __main__
+                func = getattr(__main__, function_name, None)
+                logging.debug(f"Looking for {function_name} in __main__: {func is not None}")
+
+        if not func or not callable(func):
+            logging.debug(f"Function {function_name} not found or not callable")
+            return None
+
+        import inspect
+        # Langchain tools
+        if inspect.isclass(func) and hasattr(func, 'run'):
+            original_func = func
+            func = func.run
+            function_name = original_func.__name__
+
+        sig = inspect.signature(func)
+        logging.debug(f"Function signature: {sig}")
+        
+        # Skip self, *args, **kwargs, so they don't get passed in arguments
+        parameters_list = []
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            parameters_list.append((name, param))
+
+        parameters = {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+        
+        # Parse docstring for parameter descriptions
+        docstring = inspect.getdoc(func)
+        logging.debug(f"Function docstring: {docstring}")
+        
+        param_descriptions = {}
+        if docstring:
+            import re
+            param_section = re.split(r'\s*Args:\s*', docstring)
+            logging.debug(f"Param section split: {param_section}")
+            if len(param_section) > 1:
+                param_lines = param_section[1].split('\n')
+                for line in param_lines:
+                    line = line.strip()
+                    if line and ':' in line:
+                        param_name, param_desc = line.split(':', 1)
+                        param_descriptions[param_name.strip()] = param_desc.strip()
+        
+        logging.debug(f"Parameter descriptions: {param_descriptions}")
+
+        for name, param in parameters_list:
+            param_type = "string"  # Default type
+            if param.annotation != inspect.Parameter.empty:
+                if param.annotation == int:
+                    param_type = "integer"
+                elif param.annotation == float:
+                    param_type = "number"
+                elif param.annotation == bool:
+                    param_type = "boolean"
+                elif param.annotation == list:
+                    param_type = "array"
+                elif param.annotation == dict:
+                    param_type = "object"
+            
+            param_info = {"type": param_type}
+            if name in param_descriptions:
+                param_info["description"] = param_descriptions[name]
+            
+            parameters["properties"][name] = param_info
+            if param.default == inspect.Parameter.empty:
+                parameters["required"].append(name)
+        
+        logging.debug(f"Generated parameters: {parameters}")
+
+        # Extract description from docstring
+        description = docstring.split('\n')[0] if docstring else f"Function {function_name}"
+        
+        tool_def = {
+            "type": "function",
+            "function": {
+                "name": function_name,
+                "description": description,
+                "parameters": parameters
+            }
+        }
+        logging.debug(f"Generated tool definition: {tool_def}")
+        return tool_def
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        role: Optional[str] = None,
+        goal: Optional[str] = None,
+        backstory: Optional[str] = None,
+        instructions: Optional[str] = None,
+        llm: Optional[Union[str, Any]] = None,
+        tools: Optional[List[Any]] = None,
+        function_calling_llm: Optional[Any] = None,
+        max_iter: int = 20,
+        max_rpm: Optional[int] = None,
+        max_execution_time: Optional[int] = None,
+        memory: Optional[Any] = None,
+        verbose: bool = True,
+        allow_delegation: bool = False,
+        step_callback: Optional[Any] = None,
+        cache: bool = True,
+        system_template: Optional[str] = None,
+        prompt_template: Optional[str] = None,
+        response_template: Optional[str] = None,
+        allow_code_execution: Optional[bool] = False,
+        max_retry_limit: int = 2,
+        respect_context_window: bool = True,
+        code_execution_mode: Literal["safe", "unsafe"] = "safe",
+        embedder_config: Optional[Dict[str, Any]] = None,
+        knowledge_sources: Optional[List[Any]] = None,
+        use_system_prompt: Optional[bool] = True,
+        markdown: bool = True,
+        self_reflect: bool = False,
+        max_reflect: int = 3,
+        min_reflect: int = 1,
+        reflect_llm: Optional[str] = None
+    ):
+        # Handle backward compatibility for required fields
+        if all(x is None for x in [name, role, goal, backstory, instructions]):
+            raise ValueError("At least one of name, role, goal, backstory, or instructions must be provided")
+
+        # If instructions are provided, use them to set role, goal, and backstory
+        if instructions:
+            self.name = name or "Agent"
+            self.role = role or "Assistant"
+            self.goal = goal or instructions
+            self.backstory = backstory or instructions
+            # Set self_reflect to False by default for instruction-based agents
+            self.self_reflect = False if self_reflect is None else self_reflect
+        else:
+            # Use provided values or defaults
+            self.name = name or "Agent"
+            self.role = role or "Assistant"
+            self.goal = goal or "Help the user with their tasks"
+            self.backstory = backstory or "I am an AI assistant"
+            # Default to True for traditional agents if not specified
+            self.self_reflect = True if self_reflect is None else self_reflect
+        
+        self.instructions = instructions
+        # Check for model name in environment variable if not provided
+        self.llm = llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        self.tools = tools if tools else []  # Store original tools
+        self.function_calling_llm = function_calling_llm
+        self.max_iter = max_iter
+        self.max_rpm = max_rpm
+        self.max_execution_time = max_execution_time
+        self.memory = memory
+        self.verbose = verbose
+        self.allow_delegation = allow_delegation
+        self.step_callback = step_callback
+        self.cache = cache
+        self.system_template = system_template
+        self.prompt_template = prompt_template
+        self.response_template = response_template
+        self.allow_code_execution = allow_code_execution
+        self.max_retry_limit = max_retry_limit
+        self.respect_context_window = respect_context_window
+        self.code_execution_mode = code_execution_mode
+        self.embedder_config = embedder_config
+        self.knowledge_sources = knowledge_sources
+        self.use_system_prompt = use_system_prompt
+        self.chat_history = []
+        self.markdown = markdown
+        self.max_reflect = max_reflect
+        self.min_reflect = min_reflect
+        # Use the same model selection logic for reflect_llm
+        self.reflect_llm = reflect_llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        self.console = Console()  # Create a single console instance for the agent
+        
+        # Initialize system prompt
+        self.system_prompt = f"""{self.backstory}\n
+Your Role: {self.role}\n
+Your Goal: {self.goal}
+        """
+
+    def generate_task(self) -> 'Task':
+        """Generate a Task object from the agent's instructions"""
+        from ..task.task import Task
+        
+        description = self.instructions if self.instructions else f"Execute task as {self.role} with goal: {self.goal}"
+        expected_output = "Complete the assigned task successfully"
+        
+        return Task(
+            name=self.name,
+            description=description,
+            expected_output=expected_output,
+            agent=self,
+            tools=self.tools
+        )
+
+    def execute_tool(self, function_name, arguments):
+        """
+        Execute a tool dynamically based on the function name and arguments.
+        """
+        logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
+
+        # Try to find the function in the agent's tools list first
+        func = None
+        for tool in self.tools:
+            if (callable(tool) and getattr(tool, '__name__', '') == function_name) or \
+               (inspect.isclass(tool) and tool.__name__ == function_name):
+                func = tool
+                break
+        
+        if func is None:
+            # If not found in tools, try globals and main
+            func = globals().get(function_name)
+            if not func:
+                import __main__
+                func = getattr(__main__, function_name, None)
+
+        if func:
+            try:
+                # If it's a class with run method, instantiate and call run
+                if inspect.isclass(func) and hasattr(func, 'run'):
+                    instance = func()
+                    # Extract only the parameters that run() expects
+                    run_params = {k: v for k, v in arguments.items() 
+                                if k in inspect.signature(instance.run).parameters 
+                                and k != 'self'}
+                    return instance.run(**run_params)
+                # Otherwise treat as regular function
+                elif callable(func):
+                    return func(**arguments)
+            except Exception as e:
+                error_msg = str(e)
+                logging.error(f"Error executing tool {function_name}: {error_msg}")
+                return {"error": error_msg}
+        
+        error_msg = f"Tool '{function_name}' is not callable"
+        logging.error(error_msg)
+        return {"error": error_msg}
+
+    def clear_history(self):
+        self.chat_history = []
+
+    def __str__(self):
+        return f"Agent(name='{self.name}', role='{self.role}', goal='{self.goal}')"
+
+    def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True):
+        start_time = time.time()
+        logging.debug(f"{self.name} sending messages to LLM: {messages}")
+
+        formatted_tools = []
+        if tools is None:
+            tools = self.tools
+        if tools:
+            for tool in tools:
+                if isinstance(tool, str):
+                    # Generate tool definition for string tool names
+                    tool_def = self._generate_tool_definition(tool)
+                    if tool_def:
+                        formatted_tools.append(tool_def)
+                    else:
+                        logging.warning(f"Could not generate definition for tool: {tool}")
+                elif isinstance(tool, dict):
+                    formatted_tools.append(tool)
+                elif hasattr(tool, "to_openai_tool"):
+                    formatted_tools.append(tool.to_openai_tool())
+                elif callable(tool):
+                    formatted_tools.append(self._generate_tool_definition(tool.__name__))
+                else:
+                    logging.warning(f"Tool {tool} not recognized")
+
+        try:
+            initial_response = client.chat.completions.create(
+                model=self.llm,
+                messages=messages,
+                temperature=temperature,
+                tools=formatted_tools if formatted_tools else None,
+                stream=False
+            )
+
+            tool_calls = getattr(initial_response.choices[0].message, 'tool_calls', None)
+
+            if tool_calls:
+                messages.append({
+                    "role": "assistant",
+                    "content": initial_response.choices[0].message.content,
+                    "tool_calls": tool_calls
+                })
+
+                for tool_call in tool_calls:
+                    function_name = tool_call.function.name
+                    arguments = json.loads(tool_call.function.arguments)
+
+                    if self.verbose:
+                        display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
+
+                    tool_result = self.execute_tool(function_name, arguments)
+                    results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
+
+                    if self.verbose:
+                        display_tool_call(f"Function '{function_name}' returned: {results_str}")
+
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": results_str
+                    })
+
+            if stream:
+                response_stream = client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    stream=True
+                )
+                full_response_text = ""
+                
+                # Create Live display with proper configuration
+                with Live(
+                    display_generating("", start_time),
+                    console=self.console,
+                    refresh_per_second=4,
+                    transient=True,  # Changed to False to preserve output
+                    vertical_overflow="ellipsis",
+                    auto_refresh=True
+                ) as live:
+                    for chunk in response_stream:
+                        if chunk.choices[0].delta.content:
+                            full_response_text += chunk.choices[0].delta.content
+                            live.update(display_generating(full_response_text, start_time))
+                
+                # Clear the last generating display with a blank line
+                self.console.print()
+                
+                final_response = client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    stream=False
+                )
+                return final_response
+            else:
+                if tool_calls:
+                    final_response = client.chat.completions.create(
+                        model=self.llm,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=False
+                    )
+                    return final_response
+                else:
+                    return initial_response
+
+        except Exception as e:
+            display_error(f"Error in chat completion: {e}")
+            return None
+
+    def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None):
+        if self.use_system_prompt:
+            system_prompt = f"""{self.backstory}\n
+Your Role: {self.role}\n
+Your Goal: {self.goal}
+            """
+            if output_json:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_json.schema_json()}"
+            elif output_pydantic:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_pydantic.schema_json()}"
+        else:
+            system_prompt = None
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.extend(self.chat_history)
+
+        # Modify prompt if output_json or output_pydantic is specified
+        original_prompt = prompt
+        if output_json or output_pydantic:
+            if isinstance(prompt, str):
+                prompt += "\nReturn ONLY a valid JSON object. No other text or explanation."
+            elif isinstance(prompt, list):
+                # For multimodal prompts, append to the text content
+                for item in prompt:
+                    if item["type"] == "text":
+                        item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
+                        break
+
+        if isinstance(prompt, list):
+            # If we receive a multimodal prompt list, place it directly in the user message
+            messages.append({"role": "user", "content": prompt})
+        else:
+            messages.append({"role": "user", "content": prompt})
+
+        final_response_text = None
+        reflection_count = 0
+        start_time = time.time()
+
+        while True:
+            try:
+                if self.verbose:
+                    # Handle both string and list prompts for instruction display
+                    display_text = prompt
+                    if isinstance(prompt, list):
+                        # Extract text content from multimodal prompt
+                        display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
+                    
+                    if display_text and str(display_text).strip():
+                        # Pass agent information to display_instruction
+                        agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+                        display_instruction(
+                            f"Agent {self.name} is processing prompt: {display_text}", 
+                            console=self.console,
+                            agent_name=self.name,
+                            agent_role=self.role,
+                            agent_tools=agent_tools
+                        )
+
+                response = self._chat_completion(messages, temperature=temperature, tools=tools if tools else None)
+                if not response:
+                    return None
+
+                tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
+                response_text = response.choices[0].message.content.strip()
+
+                if tool_calls:
+                    messages.append({
+                        "role": "assistant",
+                        "content": response_text,
+                        "tool_calls": tool_calls
+                    })
+                    
+                    for tool_call in tool_calls:
+                        function_name = tool_call.function.name
+                        arguments = json.loads(tool_call.function.arguments)
+
+                        if self.verbose:
+                            display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}", console=self.console)
+
+                        tool_result = self.execute_tool(function_name, arguments)
+
+                        if tool_result:
+                            if self.verbose:
+                                display_tool_call(f"Function '{function_name}' returned: {tool_result}", console=self.console)
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": json.dumps(tool_result)
+                            })
+                        else:
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": "Function returned an empty output"
+                            })
+                        
+                    response = self._chat_completion(messages, temperature=temperature)
+                    if not response:
+                        return None
+                    response_text = response.choices[0].message.content.strip()
+
+                # Handle output_json or output_pydantic if specified
+                if output_json or output_pydantic:
+                    # Add to chat history and return raw response
+                    self.chat_history.append({"role": "user", "content": original_prompt})
+                    self.chat_history.append({"role": "assistant", "content": response_text})
+                    if self.verbose:
+                        display_interaction(original_prompt, response_text, markdown=self.markdown, 
+                                         generation_time=time.time() - start_time, console=self.console)
+                    return response_text
+
+                if not self.self_reflect:
+                    self.chat_history.append({"role": "user", "content": original_prompt})
+                    self.chat_history.append({"role": "assistant", "content": response_text})
+                    if self.verbose:
+                        logging.debug(f"Agent {self.name} final response: {response_text}")
+                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                    return response_text
+
+                reflection_prompt = f"""
+Reflect on your previous response: '{response_text}'.
+Identify any flaws, improvements, or actions.
+Provide a "satisfactory" status ('yes' or 'no').
+Output MUST be JSON with 'reflection' and 'satisfactory'.
+                """
+                logging.debug(f"{self.name} reflection attempt {reflection_count+1}, sending prompt: {reflection_prompt}")
+                messages.append({"role": "user", "content": reflection_prompt})
+
+                try:
+                    reflection_response = client.beta.chat.completions.parse(
+                        model=self.reflect_llm if self.reflect_llm else self.llm,
+                        messages=messages,
+                        temperature=temperature,
+                        response_format=ReflectionOutput
+                    )
+
+                    reflection_output = reflection_response.choices[0].message.parsed
+
+                    if self.verbose:
+                        display_self_reflection(f"Agent {self.name} self reflection (using {self.reflect_llm if self.reflect_llm else self.llm}): reflection='{reflection_output.reflection}' satisfactory='{reflection_output.satisfactory}'", console=self.console)
+
+                    messages.append({"role": "assistant", "content": f"Self Reflection: {reflection_output.reflection} Satisfactory?: {reflection_output.satisfactory}"})
+
+                    # Only consider satisfactory after minimum reflections
+                    if reflection_output.satisfactory == "yes" and reflection_count >= self.min_reflect - 1:
+                        if self.verbose:
+                            display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
+                        self.chat_history.append({"role": "user", "content": prompt})
+                        self.chat_history.append({"role": "assistant", "content": response_text})
+                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                        return response_text
+
+                    # Check if we've hit max reflections
+                    if reflection_count >= self.max_reflect - 1:
+                        if self.verbose:
+                            display_self_reflection("Maximum reflection count reached, returning current response", console=self.console)
+                        self.chat_history.append({"role": "user", "content": prompt})
+                        self.chat_history.append({"role": "assistant", "content": response_text})
+                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                        return response_text
+
+                    logging.debug(f"{self.name} reflection count {reflection_count + 1}, continuing reflection process")
+                    messages.append({"role": "user", "content": "Now regenerate your response using the reflection you made"})
+                    response = self._chat_completion(messages, temperature=temperature, tools=None, stream=True)
+                    response_text = response.choices[0].message.content.strip()
+                    reflection_count += 1
+                    continue  # Continue the loop for more reflections
+
+                except Exception as e:
+                    display_error(f"Error in parsing self-reflection json {e}. Retrying", console=self.console)
+                    logging.error("Reflection parsing failed.", exc_info=True)
+                    messages.append({"role": "assistant", "content": f"Self Reflection failed."})
+                    reflection_count += 1
+                    continue  # Continue even after error to try again
+                
+            except Exception as e:
+                display_error(f"Error in chat: {e}", console=self.console)
+                return None 
+
+    def clean_json_output(self, output: str) -> str:
+        """Clean and extract JSON from response text."""
+        cleaned = output.strip()
+        # Remove markdown code blocks if present
+        if cleaned.startswith("```json"):
+            cleaned = cleaned[len("```json"):].strip()
+        if cleaned.startswith("```"):
+            cleaned = cleaned[len("```"):].strip()
+        if cleaned.endswith("```"):
+            cleaned = cleaned[:-3].strip()
+        return cleaned 
+
+    async def achat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None):
+        """Async version of chat method"""
+        try:
+            # Build system prompt
+            system_prompt = self.system_prompt
+            if output_json:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_json.schema_json()}"
+            elif output_pydantic:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_pydantic.schema_json()}"
+
+            # Build messages
+            if isinstance(prompt, str):
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt + ("\nReturn ONLY a valid JSON object. No other text or explanation." if (output_json or output_pydantic) else "")}
+                ]
+            else:
+                # For multimodal prompts
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ]
+                if output_json or output_pydantic:
+                    # Add JSON instruction to text content
+                    for item in messages[-1]["content"]:
+                        if item["type"] == "text":
+                            item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
+                            break
+
+            # Display instruction with agent info if verbose
+            if self.verbose:
+                display_text = prompt
+                if isinstance(prompt, list):
+                    display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
+                
+                if display_text and str(display_text).strip():
+                    agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+                    await adisplay_instruction(
+                        f"Agent {self.name} is processing prompt: {display_text}",
+                        console=self.console,
+                        agent_name=self.name,
+                        agent_role=self.role,
+                        agent_tools=agent_tools
+                    )
+
+            # Format tools if provided
+            formatted_tools = []
+            if tools:
+                for tool in tools:
+                    if isinstance(tool, str):
+                        tool_def = self._generate_tool_definition(tool)
+                        if tool_def:
+                            formatted_tools.append(tool_def)
+                    elif isinstance(tool, dict):
+                        formatted_tools.append(tool)
+                    elif hasattr(tool, "to_openai_tool"):
+                        formatted_tools.append(tool.to_openai_tool())
+                    elif callable(tool):
+                        formatted_tools.append(self._generate_tool_definition(tool.__name__))
+
+            # Create async OpenAI client
+            async_client = AsyncOpenAI()
+
+            # Make the API call based on the type of request
+            if tools:
+                response = await async_client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    tools=formatted_tools
+                )
+                return await self._achat_completion(response, tools)
+            elif output_json or output_pydantic:
+                response = await async_client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    response_format={"type": "json_object"}
+                )
+                # Return the raw response
+                return response.choices[0].message.content
+            else:
+                response = await async_client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature
+                )
+                return response.choices[0].message.content
+        except Exception as e:
+            display_error(f"Error in chat completion: {e}")
+            return None
+
+    async def _achat_completion(self, response, tools):
+        """Async version of _chat_completion method"""
+        try:
+            message = response.choices[0].message
+            if not hasattr(message, 'tool_calls') or not message.tool_calls:
+                return message.content
+
+            results = []
+            for tool_call in message.tool_calls:
+                try:
+                    function_name = tool_call.function.name
+                    arguments = json.loads(tool_call.function.arguments)
+                    
+                    # Find the matching tool
+                    tool = next((t for t in tools if t.__name__ == function_name), None)
+                    if not tool:
+                        display_error(f"Tool {function_name} not found")
+                        continue
+                    
+                    # Check if the tool is async
+                    if asyncio.iscoroutinefunction(tool):
+                        result = await tool(**arguments)
+                    else:
+                        # Run sync function in executor to avoid blocking
+                        loop = asyncio.get_event_loop()
+                        result = await loop.run_in_executor(None, lambda: tool(**arguments))
+                    
+                    results.append(result)
+                except Exception as e:
+                    display_error(f"Error executing tool {function_name}: {e}")
+                    results.append(None)
+
+            # If we have results, format them into a response
+            if results:
+                formatted_results = "\n".join([str(r) for r in results if r is not None])
+                if formatted_results:
+                    messages = [
+                        {"role": "system", "content": self.system_prompt},
+                        {"role": "assistant", "content": "Here are the tool results:"},
+                        {"role": "user", "content": formatted_results + "\nPlease process these results and provide a final response."}
+                    ]
+                    try:
+                        async_client = AsyncOpenAI()
+                        final_response = await async_client.chat.completions.create(
+                            model=self.llm,
+                            messages=messages,
+                            temperature=0.2
+                        )
+                        return final_response.choices[0].message.content
+                    except Exception as e:
+                        display_error(f"Error in final chat completion: {e}")
+                        return formatted_results
+                return formatted_results
+            return None
+        except Exception as e:
+            display_error(f"Error in _achat_completion: {e}")
+            return None 
+
+    def run(self):
+        """Alias for start() method"""
+        return self.start() 

agents/praisonaiagents/agents/__init__.py

@@ -0,0 +1,5 @@
+"""Agents module for managing multiple AI agents"""
+from .agents import PraisonAIAgents
+from .autoagents import AutoAgents
+
+__all__ = ['PraisonAIAgents', 'AutoAgents'] 

agents/praisonaiagents/agents/agents.py

@@ -0,0 +1,730 @@
+import os
+import time
+import json
+import logging
+from typing import Any, Dict, Optional, List
+from pydantic import BaseModel
+from rich.text import Text
+from rich.panel import Panel
+from rich.console import Console
+from ..main import display_error, TaskOutput, error_logs, client
+from ..agent.agent import Agent
+from ..task.task import Task
+from ..process.process import Process, LoopItems
+import asyncio
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+def encode_file_to_base64(file_path: str) -> str:
+    """Base64-encode a file."""
+    import base64
+    with open(file_path, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
+def process_video(video_path: str, seconds_per_frame=2):
+    """Split video into frames (base64-encoded)."""
+    import cv2
+    import base64
+    base64_frames = []
+    video = cv2.VideoCapture(video_path)
+    total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = video.get(cv2.CAP_PROP_FPS)
+    frames_to_skip = int(fps * seconds_per_frame)
+    curr_frame = 0
+    while curr_frame < total_frames:
+        video.set(cv2.CAP_PROP_POS_FRAMES, curr_frame)
+        success, frame = video.read()
+        if not success:
+            break
+        _, buffer = cv2.imencode(".jpg", frame)
+        base64_frames.append(base64.b64encode(buffer).decode("utf-8"))
+        curr_frame += frames_to_skip
+    video.release()
+    return base64_frames
+
+class PraisonAIAgents:
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None):
+        if not agents:
+            raise ValueError("At least one agent must be provided")
+            
+        self.agents = agents
+        self.tasks = {}
+        if max_retries < 3:
+            max_retries = 3
+        self.completion_checker = completion_checker if completion_checker else self.default_completion_checker
+        self.task_id_counter = 0
+        self.verbose = verbose
+        self.max_retries = max_retries
+        self.process = process
+        
+        # Check for manager_llm in environment variable if not provided
+        self.manager_llm = manager_llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        
+        # Set logger level based on verbose
+        if verbose >= 5:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+            
+        # Also set third-party loggers to WARNING
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('openai').setLevel(logging.WARNING)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+
+        if self.verbose:
+            logger.info(f"Using model {self.manager_llm} for manager")
+        
+        # If no tasks provided, generate them from agents
+        if tasks is None:
+            tasks = []
+            for agent in self.agents:
+                task = agent.generate_task()
+                tasks.append(task)
+            logger.info(f"Auto-generated {len(tasks)} tasks from agents")
+        else:
+            # Validate tasks for backward compatibility
+            if not tasks:
+                raise ValueError("If tasks are provided, at least one task must be present")
+            logger.info(f"Using {len(tasks)} provided tasks")
+        
+        # Add tasks and set their status
+        for task in tasks:
+            self.add_task(task)
+            task.status = "not started"
+            
+        # If tasks were auto-generated from agents or process is sequential, set up sequential flow
+        if len(tasks) > 1 and (process == "sequential" or all(task.next_tasks == [] for task in tasks)):
+            for i in range(len(tasks) - 1):
+                # Set up next task relationship
+                tasks[i].next_tasks = [tasks[i + 1].name]
+                # Set up context for the next task to include the current task
+                if tasks[i + 1].context is None:
+                    tasks[i + 1].context = []
+                tasks[i + 1].context.append(tasks[i])
+            logger.info("Set up sequential flow with automatic context passing")
+        
+        self._state = {}  # Add state storage at PraisonAIAgents level
+        
+        # Initialize memory system
+        self.shared_memory = None
+        if memory:
+            try:
+                from ..memory.memory import Memory
+                
+                # Get memory config from parameter or first task
+                mem_cfg = memory_config
+                if not mem_cfg:
+                    mem_cfg = next((t.config.get('memory_config') for t in tasks if hasattr(t, 'config') and t.config), None)
+                    
+                # Set default memory config if none provided
+                if not mem_cfg:
+                    mem_cfg = {
+                        "provider": "rag",
+                        "use_embedding": True,
+                        "storage": {
+                            "type": "sqlite",
+                            "path": "./.praison/memory.db"
+                        },
+                        "rag_db_path": "./.praison/chroma_db"
+                    }
+                
+                # Add embedder config if provided
+                if embedder:
+                    if isinstance(embedder, dict):
+                        mem_cfg = mem_cfg or {}
+                        mem_cfg["embedder"] = embedder
+                    else:
+                        # Handle direct embedder function
+                        mem_cfg = mem_cfg or {}
+                        mem_cfg["embedder_function"] = embedder
+
+                if mem_cfg:
+                    # Pass verbose level to Memory
+                    self.shared_memory = Memory(config=mem_cfg, verbose=verbose)
+                    if verbose >= 5:
+                        logger.info("Initialized shared memory for PraisonAIAgents")
+                    
+                    # Distribute memory to tasks
+                    for task in tasks:
+                        if not task.memory:
+                            task.memory = self.shared_memory
+                            if verbose >= 5:
+                                logger.info(f"Assigned shared memory to task {task.id}")
+                            
+            except Exception as e:
+                logger.error(f"Failed to initialize shared memory: {e}")
+            
+        # Update tasks with shared memory
+        if self.shared_memory:
+            for task in tasks:
+                if not task.memory:
+                    task.memory = self.shared_memory
+                    logger.info(f"Assigned shared memory to task {task.id}")
+
+    def add_task(self, task):
+        task_id = self.task_id_counter
+        task.id = task_id
+        self.tasks[task_id] = task
+        self.task_id_counter += 1
+        return task_id
+
+    def clean_json_output(self, output: str) -> str:
+        cleaned = output.strip()
+        if cleaned.startswith("```json"):
+            cleaned = cleaned[len("```json"):].strip()
+        if cleaned.startswith("```"):
+            cleaned = cleaned[len("```"):].strip()
+        if cleaned.endswith("```"):
+            cleaned = cleaned[:-3].strip()
+        return cleaned
+
+    def default_completion_checker(self, task, agent_output):
+        if task.output_json and task.result and task.result.json_dict:
+            return True
+        if task.output_pydantic and task.result and task.result.pydantic:
+            return True
+        return len(agent_output.strip()) > 0
+
+    async def aexecute_task(self, task_id):
+        """Async version of execute_task method"""
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        
+        # Only import multimodal dependencies if task has images
+        if task.images and task.status == "not started":
+            try:
+                import cv2
+                import base64
+                from moviepy import VideoFileClip
+            except ImportError as e:
+                display_error(f"Error: Missing required dependencies for image/video processing: {e}")
+                display_error("Please install with: pip install opencv-python moviepy")
+                task.status = "failed"
+                return None
+
+        if task.status == "not started":
+            task.status = "in progress"
+
+        executor_agent = task.agent
+
+        # Ensure tools are available from both task and agent
+        tools = task.tools or []
+        if executor_agent and executor_agent.tools:
+            tools.extend(executor_agent.tools)
+
+        task_prompt = f"""
+You need to do the following task: {task.description}.
+Expected Output: {task.expected_output}.
+"""
+        if task.context:
+            context_results = ""
+            for context_task in task.context:
+                if context_task.result:
+                    context_results += f"Result of previous task {context_task.name if context_task.name else context_task.description}: {context_task.result.raw}\n"
+                else:
+                    context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
+            task_prompt += f"""
+Here are the results of previous tasks that might be useful:\n
+{context_results}
+"""
+        task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
+
+        if self.verbose >= 2:
+            logger.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
+        logger.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
+
+        if task.images:
+            def _get_multimodal_message(text_prompt, images):
+                content = [{"type": "text", "text": text_prompt}]
+
+                for img in images:
+                    # If local file path for a valid image
+                    if os.path.exists(img):
+                        ext = os.path.splitext(img)[1].lower()
+                        # If it's a .mp4, convert to frames
+                        if ext == ".mp4":
+                            frames = process_video(img, seconds_per_frame=1)
+                            content.append({"type": "text", "text": "These are frames from the video."})
+                            for f in frames:
+                                content.append({
+                                    "type": "image_url",
+                                    "image_url": {"url": f"data:image/jpg;base64,{f}"}
+                                })
+                        else:
+                            encoded = encode_file_to_base64(img)
+                            content.append({
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/{ext.lstrip('.')};base64,{encoded}"
+                                }
+                            })
+                    else:
+                        # Treat as a remote URL
+                        content.append({
+                            "type": "image_url",
+                            "image_url": {"url": img}
+                        })
+                return content
+
+            agent_output = await executor_agent.achat(
+                _get_multimodal_message(task_prompt, task.images),
+                tools=tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
+            )
+        else:
+            agent_output = await executor_agent.achat(
+                task_prompt,
+                tools=tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
+            )
+
+        if agent_output:
+            task_output = TaskOutput(
+                description=task.description,
+                summary=task.description[:10],
+                raw=agent_output,
+                agent=executor_agent.name,
+                output_format="RAW"
+            )
+
+            if task.output_json:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    task_output.json_dict = parsed
+                    task_output.output_format = "JSON"
+                except:
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as JSON")
+                    logger.debug(f"Output that failed JSON parsing: {agent_output}")
+
+            if task.output_pydantic:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    pyd_obj = task.output_pydantic(**parsed)
+                    task_output.pydantic = pyd_obj
+                    task_output.output_format = "Pydantic"
+                except:
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
+                    logger.debug(f"Output that failed Pydantic parsing: {agent_output}")
+
+            task.result = task_output
+            return task_output
+        else:
+            task.status = "failed"
+            return None
+
+    async def arun_task(self, task_id):
+        """Async version of run_task method"""
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        if task.status == "completed":
+            logger.info(f"Task with ID {task_id} is already completed")
+            return
+
+        retries = 0
+        while task.status != "completed" and retries < self.max_retries:
+            logger.debug(f"Attempt {retries+1} for task {task_id}")
+            if task.status in ["not started", "in progress"]:
+                task_output = await self.aexecute_task(task_id)
+                if task_output and self.completion_checker(task, task_output.raw):
+                    task.status = "completed"
+                    # Run execute_callback for memory operations
+                    try:
+                        await task.execute_callback(task_output)
+                    except Exception as e:
+                        logger.error(f"Error executing memory callback for task {task_id}: {e}")
+                        logger.exception(e)
+                    
+                    # Run task callback if exists
+                    if task.callback:
+                        try:
+                            if asyncio.iscoroutinefunction(task.callback):
+                                await task.callback(task_output)
+                            else:
+                                task.callback(task_output)
+                        except Exception as e:
+                            logger.error(f"Error executing task callback for task {task_id}: {e}")
+                            logger.exception(e)
+                            
+                    self.save_output_to_file(task, task_output)
+                    if self.verbose >= 1:
+                        logger.info(f"Task {task_id} completed successfully.")
+                else:
+                    task.status = "in progress"
+                    if self.verbose >= 1:
+                        logger.info(f"Task {task_id} not completed, retrying")
+                    await asyncio.sleep(1)
+                    retries += 1
+            else:
+                if task.status == "failed":
+                    logger.info("Task is failed, resetting to in-progress for another try...")
+                    task.status = "in progress"
+                else:
+                    logger.info("Invalid Task status")
+                    break
+
+        if retries == self.max_retries and task.status != "completed":
+            logger.info(f"Task {task_id} failed after {self.max_retries} retries.")
+
+    async def arun_all_tasks(self):
+        """Async version of run_all_tasks method"""
+        process = Process(
+            tasks=self.tasks,
+            agents=self.agents,
+            manager_llm=self.manager_llm,
+            verbose=self.verbose
+        )
+        
+        if self.process == "workflow":
+            # Collect all tasks that should run in parallel
+            parallel_tasks = []
+            async for task_id in process.aworkflow():
+                if self.tasks[task_id].async_execution and self.tasks[task_id].is_start:
+                    parallel_tasks.append(task_id)
+                elif parallel_tasks:
+                    # Execute collected parallel tasks
+                    await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                    parallel_tasks = []
+                    # Run the current non-parallel task
+                    if self.tasks[task_id].async_execution:
+                        await self.arun_task(task_id)
+                    else:
+                        self.run_task(task_id)
+            
+            # Execute any remaining parallel tasks
+            if parallel_tasks:
+                await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                
+        elif self.process == "sequential":
+            async for task_id in process.asequential():
+                if self.tasks[task_id].async_execution:
+                    await self.arun_task(task_id)
+                else:
+                    self.run_task(task_id)
+        elif self.process == "hierarchical":
+            async for task_id in process.ahierarchical():
+                if isinstance(task_id, Task):
+                    task_id = self.add_task(task_id)
+                if self.tasks[task_id].async_execution:
+                    await self.arun_task(task_id)
+                else:
+                    self.run_task(task_id)
+
+    async def astart(self):
+        """Async version of start method"""
+        await self.arun_all_tasks()
+        return {
+            "task_status": self.get_all_tasks_status(),
+            "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
+        }
+
+    def save_output_to_file(self, task, task_output):
+        if task.output_file:
+            try:
+                if task.create_directory:
+                    os.makedirs(os.path.dirname(task.output_file), exist_ok=True)
+                with open(task.output_file, "w") as f:
+                    f.write(str(task_output))
+                if self.verbose >= 1:
+                    logger.info(f"Task output saved to {task.output_file}")
+            except Exception as e:
+                display_error(f"Error saving task output to file: {e}")
+
+    def execute_task(self, task_id):
+        """Synchronous version of execute_task method"""
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        
+        logger.info(f"Starting execution of task {task_id}")
+        logger.info(f"Task config: {task.config}")
+        
+        # Initialize memory before task execution
+        if not task.memory:
+            task.memory = task.initialize_memory()
+        
+        logger.info(f"Task memory status: {'Initialized' if task.memory else 'Not initialized'}")
+        
+        # Only import multimodal dependencies if task has images
+        if task.images and task.status == "not started":
+            try:
+                import cv2
+                import base64
+                from moviepy import VideoFileClip
+            except ImportError as e:
+                display_error(f"Error: Missing required dependencies for image/video processing: {e}")
+                display_error("Please install with: pip install opencv-python moviepy")
+                task.status = "failed"
+                return None
+
+        if task.status == "not started":
+            task.status = "in progress"
+
+        executor_agent = task.agent
+
+        task_prompt = f"""
+You need to do the following task: {task.description}.
+Expected Output: {task.expected_output}.
+"""
+        if task.context:
+            context_results = ""
+            for context_task in task.context:
+                if context_task.result:
+                    context_results += f"Result of previous task {context_task.name if context_task.name else context_task.description}: {context_task.result.raw}\n"
+                else:
+                    context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
+            task_prompt += f"""
+Here are the results of previous tasks that might be useful:\n
+{context_results}
+"""
+        # Add memory context if available
+        if task.memory:
+            try:
+                memory_context = task.memory.build_context_for_task(task.description)
+                if memory_context:
+                    task_prompt += f"\n\nRelevant memory context:\n{memory_context}"
+            except Exception as e:
+                logger.error(f"Error getting memory context: {e}")
+
+        task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
+
+        if self.verbose >= 2:
+            logger.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
+        logger.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
+
+        if task.images:
+            def _get_multimodal_message(text_prompt, images):
+                content = [{"type": "text", "text": text_prompt}]
+
+                for img in images:
+                    # If local file path for a valid image
+                    if os.path.exists(img):
+                        ext = os.path.splitext(img)[1].lower()
+                        # If it's a .mp4, convert to frames
+                        if ext == ".mp4":
+                            frames = process_video(img, seconds_per_frame=1)
+                            content.append({"type": "text", "text": "These are frames from the video."})
+                            for f in frames:
+                                content.append({
+                                    "type": "image_url",
+                                    "image_url": {"url": f"data:image/jpg;base64,{f}"}
+                                })
+                        else:
+                            encoded = encode_file_to_base64(img)
+                            content.append({
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/{ext.lstrip('.')};base64,{encoded}"
+                                }
+                            })
+                    else:
+                        # Treat as a remote URL
+                        content.append({
+                            "type": "image_url",
+                            "image_url": {"url": img}
+                        })
+                return content
+
+            agent_output = executor_agent.chat(
+                _get_multimodal_message(task_prompt, task.images),
+                tools=task.tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
+            )
+        else:
+            agent_output = executor_agent.chat(
+                task_prompt,
+                tools=task.tools,
+                output_json=task.output_json,
+                output_pydantic=task.output_pydantic
+            )
+
+        if agent_output:
+            # Store the response in memory
+            if task.memory:
+                try:
+                    task.store_in_memory(
+                        content=agent_output,
+                        agent_name=executor_agent.name,
+                        task_id=task_id
+                    )
+                except Exception as e:
+                    logger.error(f"Failed to store agent output in memory: {e}")
+
+            task_output = TaskOutput(
+                description=task.description,
+                summary=task.description[:10],
+                raw=agent_output,
+                agent=executor_agent.name,
+                output_format="RAW"
+            )
+
+            if task.output_json:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    task_output.json_dict = parsed
+                    task_output.output_format = "JSON"
+                except:
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as JSON")
+                    logger.debug(f"Output that failed JSON parsing: {agent_output}")
+
+            if task.output_pydantic:
+                cleaned = self.clean_json_output(agent_output)
+                try:
+                    parsed = json.loads(cleaned)
+                    pyd_obj = task.output_pydantic(**parsed)
+                    task_output.pydantic = pyd_obj
+                    task_output.output_format = "Pydantic"
+                except:
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
+                    logger.debug(f"Output that failed Pydantic parsing: {agent_output}")
+
+            task.result = task_output
+            return task_output
+        else:
+            task.status = "failed"
+            return None
+
+    def run_task(self, task_id):
+        """Synchronous version of run_task method"""
+        if task_id not in self.tasks:
+            display_error(f"Error: Task with ID {task_id} does not exist")
+            return
+        task = self.tasks[task_id]
+        if task.status == "completed":
+            logger.info(f"Task with ID {task_id} is already completed")
+            return
+
+        retries = 0
+        while task.status != "completed" and retries < self.max_retries:
+            logger.debug(f"Attempt {retries+1} for task {task_id}")
+            if task.status in ["not started", "in progress"]:
+                task_output = self.execute_task(task_id)
+                if task_output and self.completion_checker(task, task_output.raw):
+                    task.status = "completed"
+                    # Run execute_callback for memory operations
+                    try:
+                        if asyncio.get_event_loop().is_running():
+                            asyncio.create_task(task.execute_callback(task_output))
+                        else:
+                            loop = asyncio.new_event_loop()
+                            asyncio.set_event_loop(loop)
+                            loop.run_until_complete(task.execute_callback(task_output))
+                    except Exception as e:
+                        logger.error(f"Error executing memory callback for task {task_id}: {e}")
+                        logger.exception(e)
+                    
+                    # Run task callback if exists
+                    if task.callback:
+                        try:
+                            if asyncio.iscoroutinefunction(task.callback):
+                                if asyncio.get_event_loop().is_running():
+                                    asyncio.create_task(task.callback(task_output))
+                                else:
+                                    loop = asyncio.new_event_loop()
+                                    asyncio.set_event_loop(loop)
+                                    loop.run_until_complete(task.callback(task_output))
+                            else:
+                                task.callback(task_output)
+                        except Exception as e:
+                            logger.error(f"Error executing task callback for task {task_id}: {e}")
+                            logger.exception(e)
+                            
+                    self.save_output_to_file(task, task_output)
+                    if self.verbose >= 1:
+                        logger.info(f"Task {task_id} completed successfully.")
+                else:
+                    task.status = "in progress"
+                    if self.verbose >= 1:
+                        logger.info(f"Task {task_id} not completed, retrying")
+                    time.sleep(1)
+                    retries += 1
+            else:
+                if task.status == "failed":
+                    logger.info("Task is failed, resetting to in-progress for another try...")
+                    task.status = "in progress"
+                else:
+                    logger.info("Invalid Task status")
+                    break
+
+        if retries == self.max_retries and task.status != "completed":
+            logger.info(f"Task {task_id} failed after {self.max_retries} retries.")
+
+    def run_all_tasks(self):
+        """Synchronous version of run_all_tasks method"""
+        process = Process(
+            tasks=self.tasks,
+            agents=self.agents,
+            manager_llm=self.manager_llm,
+            verbose=self.verbose
+        )
+        
+        if self.process == "workflow":
+            for task_id in process.workflow():
+                self.run_task(task_id)
+        elif self.process == "sequential":
+            for task_id in process.sequential():
+                self.run_task(task_id)
+        elif self.process == "hierarchical":
+            for task_id in process.hierarchical():
+                if isinstance(task_id, Task):
+                    task_id = self.add_task(task_id)
+                self.run_task(task_id)
+
+    def get_task_status(self, task_id):
+        if task_id in self.tasks:
+            return self.tasks[task_id].status
+        return None
+
+    def get_all_tasks_status(self):
+        return {task_id: self.tasks[task_id].status for task_id in self.tasks}
+
+    def get_task_result(self, task_id):
+        if task_id in self.tasks:
+            return self.tasks[task_id].result
+        return None
+
+    def get_task_details(self, task_id):
+        if task_id in self.tasks:
+            return str(self.tasks[task_id])
+        return None
+
+    def get_agent_details(self, agent_name):
+        agent = [task.agent for task in self.tasks.values() if task.agent and task.agent.name == agent_name]
+        if agent:
+            return str(agent[0])
+        return None
+
+    def start(self):
+        self.run_all_tasks()
+        return {
+            "task_status": self.get_all_tasks_status(),
+            "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
+        } 
+
+    def set_state(self, key: str, value: Any) -> None:
+        """Set a state value"""
+        self._state[key] = value
+
+    def get_state(self, key: str, default: Any = None) -> Any:
+        """Get a state value"""
+        return self._state.get(key, default)
+
+    def update_state(self, updates: Dict) -> None:
+        """Update multiple state values"""
+        self._state.update(updates)
+
+    def clear_state(self) -> None:
+        """Clear all state values"""
+        self._state.clear() 

agents/praisonaiagents/agents/autoagents.py

@@ -0,0 +1,335 @@
+"""
+AutoAgents - A class for automatically creating and managing AI agents and tasks.
+
+This class provides a simplified interface for creating and running AI agents with tasks.
+It automatically handles agent creation, task setup, and execution flow.
+"""
+
+from .agents import PraisonAIAgents
+from ..agent.agent import Agent
+from ..task.task import Task
+from typing import List, Any, Optional, Dict, Union
+import logging
+import os
+from pydantic import BaseModel, Field
+from ..main import display_instruction, display_tool_call, display_interaction, client
+
+# Define Pydantic models for structured output
+class TaskConfig(BaseModel):
+    name: str
+    description: str
+    expected_output: str
+    tools: List[str]
+
+class AgentConfig(BaseModel):
+    name: str
+    role: str
+    goal: str
+    backstory: str
+    tools: List[str]
+    tasks: List[TaskConfig]
+
+class AutoAgentsConfig(BaseModel):
+    main_instruction: str
+    process_type: str
+    agents: List[AgentConfig]
+
+class AutoAgents(PraisonAIAgents):
+    def __init__(
+        self,
+        instructions: str,
+        tools: Optional[List[Any]] = None,
+        verbose: bool = False,
+        process: str = "sequential",
+        manager_llm: Optional[str] = None,
+        max_retries: int = 5,
+        completion_checker: Optional[Any] = None,
+        allow_code_execution: bool = False,
+        memory: bool = True,
+        markdown: bool = True,
+        self_reflect: bool = False,
+        max_reflect: int = 3,
+        min_reflect: int = 1,
+        llm: Optional[str] = None,
+        function_calling_llm: Optional[str] = None,
+        respect_context_window: bool = True,
+        code_execution_mode: str = "safe",
+        embedder_config: Optional[Dict[str, Any]] = None,
+        knowledge_sources: Optional[List[Any]] = None,
+        use_system_prompt: bool = True,
+        cache: bool = True,
+        allow_delegation: bool = False,
+        step_callback: Optional[Any] = None,
+        system_template: Optional[str] = None,
+        prompt_template: Optional[str] = None,
+        response_template: Optional[str] = None,
+        max_rpm: Optional[int] = None,
+        max_execution_time: Optional[int] = None,
+        max_iter: int = 20,
+        reflect_llm: Optional[str] = None,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        max_agents: int = 3  # New parameter for maximum number of agents
+    ):
+        """Initialize AutoAgents with configuration for automatic agent and task creation."""
+        if max_agents < 1:
+            raise ValueError("max_agents must be at least 1")
+        if max_agents > 10:
+            raise ValueError("max_agents cannot exceed 10")
+            
+        # Store all configuration parameters first
+        self.instructions = instructions
+        self.tools = tools or []
+        self.verbose = verbose  # Store verbose parameter
+        self.max_agents = max_agents  # Store max_agents parameter
+        self.allow_code_execution = allow_code_execution
+        self.memory = memory
+        self.markdown = markdown
+        self.self_reflect = self_reflect
+        self.max_reflect = max_reflect
+        self.min_reflect = min_reflect
+        self.llm = llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        self.function_calling_llm = function_calling_llm
+        self.respect_context_window = respect_context_window
+        self.code_execution_mode = code_execution_mode
+        self.embedder_config = embedder_config
+        self.knowledge_sources = knowledge_sources
+        self.use_system_prompt = use_system_prompt
+        self.cache = cache
+        self.allow_delegation = allow_delegation
+        self.step_callback = step_callback
+        self.system_template = system_template
+        self.prompt_template = prompt_template
+        self.response_template = response_template
+        self.max_rpm = max_rpm
+        self.max_execution_time = max_execution_time
+        self.max_iter = max_iter
+        self.reflect_llm = reflect_llm
+        
+        # Display initial instruction
+        if self.verbose:
+            display_instruction(f"🎯 Main Task: {self.instructions}")
+            display_instruction(f"📊 Maximum Agents: {self.max_agents}")
+            if self.tools:
+                tool_names = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+                display_tool_call(f"🛠️  Available Tools: {', '.join(tool_names)}")
+        
+        # Generate agents and tasks configuration
+        config = self._generate_config()
+        agents, tasks = self._create_agents_and_tasks(config)
+        
+        # Display agents and their tasks
+        if self.verbose:
+            self._display_agents_and_tasks(agents, tasks)
+        
+        # Initialize parent class with generated agents and tasks
+        super().__init__(
+            agents=agents,
+            tasks=tasks,
+            verbose=verbose,
+            completion_checker=completion_checker,
+            max_retries=max_retries,
+            process=process,
+            manager_llm=manager_llm
+        )
+
+    def _display_agents_and_tasks(self, agents: List[Agent], tasks: List[Task]):
+        """Display the created agents and their assigned tasks"""
+        display_instruction("\n🤖 Generated Agents and Tasks:")
+        
+        # Create a mapping of agents to their tasks
+        agent_tasks = {}
+        for task in tasks:
+            if task.agent not in agent_tasks:
+                agent_tasks[task.agent] = []
+            agent_tasks[task.agent].append(task)
+        
+        # Display each agent and their tasks
+        for agent in agents:
+            agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in agent.tools]
+            display_interaction(
+                f"\n👤 Agent: {agent.name}",
+                f"""Role: {agent.role}
+Goal: {agent.goal}
+Tools: {', '.join(agent_tools)}"""
+            )
+            
+            # Display tasks for this agent
+            if agent in agent_tasks:
+                for i, task in enumerate(agent_tasks[agent], 1):
+                    task_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in task.tools]
+                    display_instruction(
+                        f"""  📋 Task {i}: {task.name}
+     Description: {task.description}
+     Expected Output: {task.expected_output}
+     Tools: {', '.join(task_tools)}"""
+                    )
+
+    def _get_available_tools(self) -> List[str]:
+        """Get list of available tools"""
+        if not self.tools:
+            return []
+        return [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+
+    def _get_tool_by_name(self, tool_name: str) -> Optional[Any]:
+        """Get tool object by its name"""
+        for tool in self.tools:
+            if (hasattr(tool, '__name__') and tool.__name__ == tool_name) or str(tool) == tool_name:
+                return tool
+        return None
+
+    def _assign_tools_to_agent(self, agent_config: AgentConfig) -> List[Any]:
+        """
+        Assign appropriate tools to an agent based on its role and tasks.
+        
+        Args:
+            agent_config: The agent configuration containing role and required tools
+            
+        Returns:
+            List of tool objects assigned to this agent
+        """
+        assigned_tools = []
+        tool_names = set(agent_config.tools)
+        
+        # Also look at task requirements
+        for task in agent_config.tasks:
+            tool_names.update(task.tools)
+        
+        # Assign tools that match the requirements
+        for tool_name in tool_names:
+            tool = self._get_tool_by_name(tool_name)
+            if tool:
+                assigned_tools.append(tool)
+        
+        # If no specific tools matched but we have tools available,
+        # assign all tools to ensure functionality
+        if not assigned_tools and self.tools:
+            assigned_tools = self.tools
+            
+        return assigned_tools
+
+    def _generate_config(self) -> AutoAgentsConfig:
+        """Generate the configuration for agents and tasks"""
+        prompt = f"""
+Generate a configuration for AI agents to accomplish this task: "{self.instructions}"
+
+The configuration should include:
+1. A main instruction that clearly states the overall goal
+2. A process type (sequential, workflow, or hierarchical)
+3. A list of maximum {self.max_agents} agents (no more, no less), each with:
+   - Name, role, goal, and backstory
+   - List of required tools from: {self._get_available_tools()}
+   - Only add tools that are needed for the agent to perform its task
+   - Only one task per agent. Add more than one task if absolutely necessary.
+   - List of specific tasks they need to perform
+   - Whether they should self-reflect or allow delegation
+
+Requirements:
+1. Each agent should have clear, focused responsibilities
+2. Tasks should be broken down into manageable steps
+3. Tool selection should be appropriate for each task
+4. The process type should match the task requirements
+5. Generate maximum {self.max_agents} agents to handle this task efficiently
+
+Return the configuration in a structured JSON format matching the AutoAgentsConfig schema.
+"""
+        
+        try:
+            response = client.beta.chat.completions.parse(
+                model=self.llm,
+                response_format=AutoAgentsConfig,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant designed to generate AI agent configurations."},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            # Ensure we have exactly max_agents number of agents
+            if len(response.choices[0].message.parsed.agents) > self.max_agents:
+                response.choices[0].message.parsed.agents = response.choices[0].message.parsed.agents[:self.max_agents]
+            elif len(response.choices[0].message.parsed.agents) < self.max_agents:
+                logging.warning(f"Generated {len(response.choices[0].message.parsed.agents)} agents, expected {self.max_agents}")
+            
+            return response.choices[0].message.parsed
+        except Exception as e:
+            logging.error(f"Error generating configuration: {e}")
+            raise
+
+    def _create_agents_and_tasks(self, config: AutoAgentsConfig) -> tuple[List[Agent], List[Task]]:
+        """Create agents and tasks from configuration"""
+        agents = []
+        tasks = []
+        
+        for agent_config in config.agents:
+            # Get appropriate tools for this agent
+            agent_tools = self._assign_tools_to_agent(agent_config)
+            
+            # Create the agent with all parameters
+            agent = Agent(
+                name=agent_config.name,
+                role=agent_config.role,
+                goal=agent_config.goal,
+                backstory=agent_config.backstory,
+                tools=agent_tools,  # Use assigned tools
+                verbose=self.verbose >= 1,
+                allow_code_execution=self.allow_code_execution,
+                memory=self.memory,
+                markdown=self.markdown,
+                self_reflect=self.self_reflect,
+                max_reflect=self.max_reflect,
+                min_reflect=self.min_reflect,
+                llm=self.llm,
+                function_calling_llm=self.function_calling_llm,
+                respect_context_window=self.respect_context_window,
+                code_execution_mode=self.code_execution_mode,
+                embedder_config=self.embedder_config,
+                knowledge_sources=self.knowledge_sources,
+                use_system_prompt=self.use_system_prompt,
+                cache=self.cache,
+                allow_delegation=self.allow_delegation,
+                step_callback=self.step_callback,
+                system_template=self.system_template,
+                prompt_template=self.prompt_template,
+                response_template=self.response_template,
+                max_rpm=self.max_rpm,
+                max_execution_time=self.max_execution_time,
+                max_iter=self.max_iter,
+                reflect_llm=self.reflect_llm
+            )
+            agents.append(agent)
+            
+            # Create tasks for this agent
+            for task_config in agent_config.tasks:
+                # Get task-specific tools
+                task_tools = [self._get_tool_by_name(t) for t in task_config.tools]
+                task_tools = [t for t in task_tools if t]  # Remove None values
+                
+                # If no specific tools matched, use agent's tools
+                if not task_tools:
+                    task_tools = agent_tools
+                
+                task = Task(
+                    name=task_config.name,
+                    description=task_config.description,
+                    expected_output=task_config.expected_output,
+                    agent=agent,
+                    tools=task_tools  # Use task-specific tools
+                )
+                tasks.append(task)
+        
+        return agents, tasks
+
+    async def astart(self):
+        """
+        Async version of start() method.
+        Creates tasks based on the instructions, then starts execution.
+        Returns the task status and results dictionary.
+        """
+        return await super().astart()
+
+    def start(self):
+        """
+        Creates tasks based on the instructions, then starts execution.
+        Returns the task status and results dictionary.
+        """
+        return super().start() 

agents/praisonaiagents/main.py

@@ -0,0 +1,373 @@
+import os
+import time
+import json
+import logging
+from typing import List, Optional, Dict, Any, Union, Literal, Type
+from openai import OpenAI
+from pydantic import BaseModel
+from rich import print
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.markdown import Markdown
+from rich.logging import RichHandler
+from rich.live import Live
+import asyncio
+
+LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
+
+logging.basicConfig(
+    level=getattr(logging, LOGLEVEL, logging.INFO),
+    format="%(asctime)s %(filename)s:%(lineno)d %(levelname)s %(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True)]
+)
+
+# Global list to store error logs
+error_logs = []
+
+# Separate registries for sync and async callbacks
+sync_display_callbacks = {}
+async_display_callbacks = {}
+
+# At the top of the file, add display_callbacks to __all__
+__all__ = [
+    'error_logs',
+    'register_display_callback',
+    'sync_display_callbacks',
+    'async_display_callbacks',
+    # ... other exports
+]
+
+def register_display_callback(display_type: str, callback_fn, is_async: bool = False):
+    """Register a synchronous or asynchronous callback function for a specific display type.
+    
+    Args:
+        display_type (str): Type of display event ('interaction', 'self_reflection', etc.)
+        callback_fn: The callback function to register
+        is_async (bool): Whether the callback is asynchronous
+    """
+    if is_async:
+        async_display_callbacks[display_type] = callback_fn
+    else:
+        sync_display_callbacks[display_type] = callback_fn
+
+async def execute_callback(display_type: str, **kwargs):
+    """Execute both sync and async callbacks for a given display type.
+    
+    Args:
+        display_type (str): Type of display event
+        **kwargs: Arguments to pass to the callback functions
+    """
+    # Execute synchronous callback if registered
+    if display_type in sync_display_callbacks:
+        callback = sync_display_callbacks[display_type]
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, lambda: callback(**kwargs))
+    
+    # Execute asynchronous callback if registered
+    if display_type in async_display_callbacks:
+        callback = async_display_callbacks[display_type]
+        await callback(**kwargs)
+
+def _clean_display_content(content: str, max_length: int = 20000) -> str:
+    """Helper function to clean and truncate content for display."""
+    if not content or not str(content).strip():
+        return ""
+        
+    content = str(content)
+    # Handle base64 content
+    if "base64" in content:
+        content_parts = []
+        for line in content.split('\n'):
+            if "base64" not in line:
+                content_parts.append(line)
+        content = '\n'.join(content_parts)
+    
+    # Truncate if too long
+    if len(content) > max_length:
+        content = content[:max_length] + "..."
+    
+    return content.strip()
+
+def display_interaction(message, response, markdown=True, generation_time=None, console=None):
+    """Synchronous version of display_interaction."""
+    if console is None:
+        console = Console()
+    
+    if isinstance(message, list):
+        text_content = next((item["text"] for item in message if item["type"] == "text"), "")
+        message = text_content
+
+    message = _clean_display_content(str(message))
+    response = _clean_display_content(str(response))
+
+    # Execute synchronous callback if registered
+    if 'interaction' in sync_display_callbacks:
+        sync_display_callbacks['interaction'](
+            message=message,
+            response=response,
+            markdown=markdown,
+            generation_time=generation_time
+        )
+
+    # Rest of the display logic...
+    if generation_time:
+        console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
+
+    if markdown:
+        console.print(Panel.fit(Markdown(message), title="Task", border_style="cyan"))
+        console.print(Panel.fit(Markdown(response), title="Response", border_style="cyan"))
+    else:
+        console.print(Panel.fit(Text(message, style="bold green"), title="Task", border_style="cyan"))
+        console.print(Panel.fit(Text(response, style="bold blue"), title="Response", border_style="cyan"))
+
+def display_self_reflection(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    # Execute callback if registered
+    if 'self_reflection' in sync_display_callbacks:
+        sync_display_callbacks['self_reflection'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
+
+def display_instruction(message: str, console=None, agent_name: str = None, agent_role: str = None, agent_tools: List[str] = None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    # Execute callback if registered
+    if 'instruction' in sync_display_callbacks:
+        sync_display_callbacks['instruction'](message=message)
+    
+    # Display agent info if available
+    if agent_name:
+        agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
+        if agent_role:
+            agent_info += f"\n[bold #B4B4B3]Role:[/] [#FFE5E5]{agent_role}[/]"
+        if agent_tools:
+            tools_str = ", ".join(f"[italic #B4D4FF]{tool}[/]" for tool in agent_tools)
+            agent_info += f"\n[bold #86A789]Tools:[/] {tools_str}"
+        console.print(Panel(agent_info, border_style="#D2E3C8", title="[bold]Agent Info[/]", title_align="left", padding=(1, 2)))
+    
+    # Only print if log level is DEBUG
+    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+        console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
+
+def display_tool_call(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    # Execute callback if registered
+    if 'tool_call' in sync_display_callbacks:
+        sync_display_callbacks['tool_call'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
+
+def display_error(message: str, console=None):
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    # Execute callback if registered
+    if 'error' in sync_display_callbacks:
+        sync_display_callbacks['error'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
+    error_logs.append(message)
+
+def display_generating(content: str = "", start_time: Optional[float] = None):
+    if not content or not str(content).strip():
+        return Panel("", title="", border_style="green")
+    
+    elapsed_str = ""
+    if start_time is not None:
+        elapsed = time.time() - start_time
+        elapsed_str = f" {elapsed:.1f}s"
+    
+    content = _clean_display_content(str(content))
+    
+    # Execute callback if registered
+    if 'generating' in sync_display_callbacks:
+        sync_display_callbacks['generating'](
+            content=content,
+            elapsed_time=elapsed_str.strip() if elapsed_str else None
+        )
+    
+    return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
+
+# Async versions with 'a' prefix
+async def adisplay_interaction(message, response, markdown=True, generation_time=None, console=None):
+    """Async version of display_interaction."""
+    if console is None:
+        console = Console()
+    
+    if isinstance(message, list):
+        text_content = next((item["text"] for item in message if item["type"] == "text"), "")
+        message = text_content
+
+    message = _clean_display_content(str(message))
+    response = _clean_display_content(str(response))
+
+    # Execute callbacks
+    await execute_callback(
+        'interaction',
+        message=message,
+        response=response,
+        markdown=markdown,
+        generation_time=generation_time
+    )
+
+    # Rest of the display logic...
+    if generation_time:
+        console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
+
+    if markdown:
+        console.print(Panel.fit(Markdown(message), title="Task", border_style="cyan"))
+        console.print(Panel.fit(Markdown(response), title="Response", border_style="cyan"))
+    else:
+        console.print(Panel.fit(Text(message, style="bold green"), title="Task", border_style="cyan"))
+        console.print(Panel.fit(Text(response, style="bold blue"), title="Response", border_style="cyan"))
+
+async def adisplay_self_reflection(message: str, console=None):
+    """Async version of display_self_reflection."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'self_reflection' in async_display_callbacks:
+        await async_display_callbacks['self_reflection'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
+
+async def adisplay_instruction(message: str, console=None, agent_name: str = None, agent_role: str = None, agent_tools: List[str] = None):
+    """Async version of display_instruction."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'instruction' in async_display_callbacks:
+        await async_display_callbacks['instruction'](message=message)
+    
+    # Display agent info if available
+    if agent_name:
+        agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
+        if agent_role:
+            agent_info += f"\n[bold #B4B4B3]Role:[/] [#FFE5E5]{agent_role}[/]"
+        if agent_tools:
+            tools_str = ", ".join(f"[italic #B4D4FF]{tool}[/]" for tool in agent_tools)
+            agent_info += f"\n[bold #86A789]Tools:[/] {tools_str}"
+        console.print(Panel(agent_info, border_style="#D2E3C8", title="[bold]Agent Info[/]", title_align="left", padding=(1, 2)))
+    
+    # Only print if log level is DEBUG
+    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+        console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
+
+async def adisplay_tool_call(message: str, console=None):
+    """Async version of display_tool_call."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'tool_call' in async_display_callbacks:
+        await async_display_callbacks['tool_call'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
+
+async def adisplay_error(message: str, console=None):
+    """Async version of display_error."""
+    if not message or not message.strip():
+        return
+    if console is None:
+        console = Console()
+    message = _clean_display_content(str(message))
+    
+    if 'error' in async_display_callbacks:
+        await async_display_callbacks['error'](message=message)
+    
+    console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
+    error_logs.append(message)
+
+async def adisplay_generating(content: str = "", start_time: Optional[float] = None):
+    """Async version of display_generating."""
+    if not content or not str(content).strip():
+        return Panel("", title="", border_style="green")
+    
+    elapsed_str = ""
+    if start_time is not None:
+        elapsed = time.time() - start_time
+        elapsed_str = f" {elapsed:.1f}s"
+    
+    content = _clean_display_content(str(content))
+    
+    if 'generating' in async_display_callbacks:
+        await async_display_callbacks['generating'](
+            content=content,
+            elapsed_time=elapsed_str.strip() if elapsed_str else None
+        )
+    
+    return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
+
+def clean_triple_backticks(text: str) -> str:
+    """Remove triple backticks and surrounding json fences from a string."""
+    cleaned = text.strip()
+    if cleaned.startswith("```json"):
+        cleaned = cleaned[len("```json"):].strip()
+    if cleaned.startswith("```"):
+        cleaned = cleaned[len("```"):].strip()
+    if cleaned.endswith("```"):
+        cleaned = cleaned[:-3].strip()
+    return cleaned
+
+class ReflectionOutput(BaseModel):
+    reflection: str
+    satisfactory: Literal["yes", "no"]
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+class TaskOutput(BaseModel):
+    description: str
+    summary: Optional[str] = None
+    raw: str
+    pydantic: Optional[BaseModel] = None
+    json_dict: Optional[Dict[str, Any]] = None
+    agent: str
+    output_format: Literal["RAW", "JSON", "Pydantic"] = "RAW"
+
+    def json(self) -> Optional[str]:
+        if self.output_format == "JSON" and self.json_dict:
+            return json.dumps(self.json_dict)
+        return None
+
+    def to_dict(self) -> dict:
+        output_dict = {}
+        if self.json_dict:
+            output_dict.update(self.json_dict)
+        if self.pydantic:
+            output_dict.update(self.pydantic.model_dump())
+        return output_dict
+
+    def __str__(self):
+        if self.pydantic:
+            return str(self.pydantic)
+        elif self.json_dict:
+            return json.dumps(self.json_dict)
+        else:
+            return self.raw 

agents/praisonaiagents/memory/memory.py

@@ -0,0 +1,931 @@
+import os
+import sqlite3
+import json
+import time
+import shutil
+from typing import Any, Dict, List, Optional, Union, Literal
+import logging
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+try:
+    import chromadb
+    from chromadb.config import Settings as ChromaSettings
+    CHROMADB_AVAILABLE = True
+except ImportError:
+    CHROMADB_AVAILABLE = False
+    logger.warning("To use memory features, please run: pip install \"praisonaiagents[memory]\"")
+
+try:
+    import mem0
+    MEM0_AVAILABLE = True
+except ImportError:
+    MEM0_AVAILABLE = False
+
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+
+
+
+class Memory:
+    """
+    A single-file memory manager covering:
+    - Short-term memory (STM) for ephemeral context
+    - Long-term memory (LTM) for persistent knowledge
+    - Entity memory (structured data about named entities)
+    - User memory (preferences/history for each user)
+    - Quality score logic for deciding which data to store in LTM
+    - Context building from multiple memory sources
+
+    Config example:
+    {
+      "provider": "rag" or "mem0" or "none",
+      "use_embedding": True,
+      "short_db": "short_term.db",
+      "long_db": "long_term.db",
+      "rag_db_path": "rag_db",   # optional path for local embedding store
+      "config": {
+        "api_key": "...",       # if mem0 usage
+        "org_id": "...",
+        "project_id": "...",
+        ...
+      }
+    }
+    """
+
+    def __init__(self, config: Dict[str, Any], verbose: int = 0):
+        self.cfg = config or {}
+        self.verbose = verbose
+        
+        # Set logger level based on verbose
+        if verbose >= 5:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+            
+        # Also set ChromaDB and OpenAI client loggers to WARNING
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('openai').setLevel(logging.WARNING)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+        logging.getLogger('chromadb.segment.impl.vector.local_persistent_hnsw').setLevel(logging.ERROR)
+            
+        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)
+
+        # Create .praison directory if it doesn't exist
+        os.makedirs(".praison", exist_ok=True)
+
+        # Short-term DB
+        self.short_db = self.cfg.get("short_db", ".praison/short_term.db")
+        self._init_stm()
+
+        # Long-term DB
+        self.long_db = self.cfg.get("long_db", ".praison/long_term.db")
+        self._init_ltm()
+
+        # Conditionally init Mem0 or local RAG
+        if self.use_mem0:
+            self._init_mem0()
+        elif self.use_rag:
+            self._init_chroma()
+
+    def _log_verbose(self, msg: str, level: int = logging.INFO):
+        """Only log if verbose >= 5"""
+        if self.verbose >= 5:
+            logger.log(level, msg)
+
+    # -------------------------------------------------------------------------
+    #                          Initialization
+    # -------------------------------------------------------------------------
+    def _init_stm(self):
+        """Creates or verifies short-term memory table."""
+        os.makedirs(os.path.dirname(self.short_db) or ".", exist_ok=True)
+        conn = sqlite3.connect(self.short_db)
+        c = conn.cursor()
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS short_mem (
+            id TEXT PRIMARY KEY,
+            content TEXT,
+            meta TEXT,
+            created_at REAL
+        )
+        """)
+        conn.commit()
+        conn.close()
+
+    def _init_ltm(self):
+        """Creates or verifies long-term memory table."""
+        os.makedirs(os.path.dirname(self.long_db) or ".", exist_ok=True)
+        conn = sqlite3.connect(self.long_db)
+        c = conn.cursor()
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS long_mem (
+            id TEXT PRIMARY KEY,
+            content TEXT,
+            meta TEXT,
+            created_at REAL
+        )
+        """)
+        conn.commit()
+        conn.close()
+
+    def _init_mem0(self):
+        """Initialize Mem0 client for agent or user memory."""
+        from mem0 import MemoryClient
+        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)
+        else:
+            self.mem0_client = MemoryClient(api_key=api_key)
+
+    def _init_chroma(self):
+        """Initialize a local Chroma client for embedding-based search."""
+        try:
+            # Create directory if it doesn't exist
+            rag_path = self.cfg.get("rag_db_path", "chroma_db")
+            os.makedirs(rag_path, exist_ok=True)
+
+            # Initialize ChromaDB with persistent storage
+            self.chroma_client = chromadb.PersistentClient(
+                path=rag_path,
+                settings=ChromaSettings(
+                    anonymized_telemetry=False,
+                    allow_reset=True
+                )
+            )
+
+            collection_name = "memory_store"
+            try:
+                self.chroma_col = self.chroma_client.get_collection(name=collection_name)
+                self._log_verbose("Using existing ChromaDB collection")
+            except Exception as e:
+                self._log_verbose(f"Collection '{collection_name}' not found. Creating new collection. Error: {e}")
+                self.chroma_col = self.chroma_client.create_collection(
+                    name=collection_name,
+                    metadata={"hnsw:space": "cosine"}
+                )
+                self._log_verbose("Created new ChromaDB collection")
+
+        except Exception as e:
+            self._log_verbose(f"Failed to initialize ChromaDB: {e}", logging.ERROR)
+            self.use_rag = False
+
+    # -------------------------------------------------------------------------
+    #                      Basic Quality Score Computation
+    # -------------------------------------------------------------------------
+    def compute_quality_score(
+        self,
+        completeness: float,
+        relevance: float,
+        clarity: float,
+        accuracy: float,
+        weights: Dict[str, float] = None
+    ) -> float:
+        """
+        Combine multiple sub-metrics into one final score, as an example.
+
+        Args:
+            completeness (float): 0-1
+            relevance (float): 0-1
+            clarity (float): 0-1
+            accuracy (float): 0-1
+            weights (Dict[str, float]): optional weighting like {"completeness": 0.25, "relevance": 0.3, ...}
+
+        Returns:
+            float: Weighted average 0-1
+        """
+        if not weights:
+            weights = {
+                "completeness": 0.25,
+                "relevance": 0.25,
+                "clarity": 0.25,
+                "accuracy": 0.25
+            }
+        total = (completeness * weights["completeness"]
+                 + relevance   * weights["relevance"]
+                 + clarity     * weights["clarity"]
+                 + accuracy    * weights["accuracy"]
+                )
+        return round(total, 3)  # e.g. round to 3 decimal places
+
+    # -------------------------------------------------------------------------
+    #                           Short-Term Methods
+    # -------------------------------------------------------------------------
+    def store_short_term(
+        self,
+        text: str,
+        metadata: Dict[str, Any] = None,
+        completeness: float = None,
+        relevance: float = None,
+        clarity: float = None,
+        accuracy: float = None,
+        weights: Dict[str, float] = None,
+        evaluator_quality: float = None
+    ):
+        """Store in short-term memory with optional quality metrics"""
+        logger.info(f"Storing in short-term memory: {text[:100]}...")
+        logger.info(f"Metadata: {metadata}")
+        
+        metadata = self._process_quality_metrics(
+            metadata, completeness, relevance, clarity, 
+            accuracy, weights, evaluator_quality
+        )
+        logger.info(f"Processed metadata: {metadata}")
+        
+        # Existing store logic
+        try:
+            conn = sqlite3.connect(self.short_db)
+            ident = str(time.time_ns())
+            conn.execute(
+                "INSERT INTO short_mem (id, content, meta, created_at) VALUES (?,?,?,?)",
+                (ident, text, json.dumps(metadata), time.time())
+            )
+            conn.commit()
+            conn.close()
+            logger.info(f"Successfully stored in short-term memory with ID: {ident}")
+        except Exception as e:
+            logger.error(f"Failed to store in short-term memory: {e}")
+            raise
+
+    def search_short_term(
+        self, 
+        query: str, 
+        limit: int = 5,
+        min_quality: float = 0.0,
+        relevance_cutoff: float = 0.0
+    ) -> List[Dict[str, Any]]:
+        """Search short-term memory with optional quality filter"""
+        self._log_verbose(f"Searching short memory for: {query}")
+        
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            results = self.mem0_client.search(query=query, limit=limit)
+            filtered = [r for r in results if r.get("score", 1.0) >= relevance_cutoff]
+            return filtered
+            
+        elif self.use_rag and hasattr(self, "chroma_col"):
+            try:
+                from openai import OpenAI
+                client = OpenAI()
+                
+                response = client.embeddings.create(
+                    input=query,
+                    model="text-embedding-3-small"
+                )
+                query_embedding = response.data[0].embedding
+                
+                resp = self.chroma_col.query(
+                    query_embeddings=[query_embedding],
+                    n_results=limit
+                )
+                
+                results = []
+                if resp["ids"]:
+                    for i in range(len(resp["ids"][0])):
+                        metadata = resp["metadatas"][0][i] if "metadatas" in resp else {}
+                        quality = metadata.get("quality", 0.0)
+                        score = 1.0 - (resp["distances"][0][i] if "distances" in resp else 0.0)
+                        if quality >= min_quality and score >= relevance_cutoff:
+                            results.append({
+                                "id": resp["ids"][0][i],
+                                "text": resp["documents"][0][i],
+                                "metadata": metadata,
+                                "score": score
+                            })
+                return results
+            except Exception as e:
+                self._log_verbose(f"Error searching ChromaDB: {e}", logging.ERROR)
+                return []
+        
+        else:
+            # Local fallback
+            conn = sqlite3.connect(self.short_db)
+            c = conn.cursor()
+            rows = c.execute(
+                "SELECT id, content, meta FROM short_mem WHERE content LIKE ? LIMIT ?",
+                (f"%{query}%", limit)
+            ).fetchall()
+            conn.close()
+
+            results = []
+            for row in rows:
+                meta = json.loads(row[2] or "{}")
+                quality = meta.get("quality", 0.0)
+                if quality >= min_quality:
+                    results.append({
+                        "id": row[0],
+                        "text": row[1],
+                        "metadata": meta
+                    })
+            return results
+
+    def reset_short_term(self):
+        """Completely clears short-term memory."""
+        conn = sqlite3.connect(self.short_db)
+        conn.execute("DELETE FROM short_mem")
+        conn.commit()
+        conn.close()
+
+    # -------------------------------------------------------------------------
+    #                           Long-Term Methods
+    # -------------------------------------------------------------------------
+    def _sanitize_metadata(self, metadata: Dict) -> Dict:
+        """Sanitize metadata for ChromaDB - convert to acceptable types"""
+        sanitized = {}
+        for k, v in metadata.items():
+            if v is None:
+                continue
+            if isinstance(v, (str, int, float, bool)):
+                sanitized[k] = v
+            elif isinstance(v, dict):
+                # Convert dict to string representation
+                sanitized[k] = str(v)
+            else:
+                # Convert other types to string
+                sanitized[k] = str(v)
+        return sanitized
+
+    def store_long_term(
+        self,
+        text: str,
+        metadata: Dict[str, Any] = None,
+        completeness: float = None,
+        relevance: float = None,
+        clarity: float = None,
+        accuracy: float = None,
+        weights: Dict[str, float] = None,
+        evaluator_quality: float = None
+    ):
+        """Store in long-term memory with optional quality metrics"""
+        logger.info(f"Storing in long-term memory: {text[:100]}...")
+        logger.info(f"Initial metadata: {metadata}")
+        
+        # Process metadata
+        metadata = metadata or {}
+        metadata = self._process_quality_metrics(
+            metadata, completeness, relevance, clarity,
+            accuracy, weights, evaluator_quality
+        )
+        logger.info(f"Processed metadata: {metadata}")
+        
+        # Generate unique ID
+        ident = str(time.time_ns())
+        created = time.time()
+
+        # Store in SQLite
+        try:
+            conn = sqlite3.connect(self.long_db)
+            conn.execute(
+                "INSERT INTO long_mem (id, content, meta, created_at) VALUES (?,?,?,?)",
+                (ident, text, json.dumps(metadata), created)
+            )
+            conn.commit()
+            conn.close()
+            logger.info(f"Successfully stored in SQLite with ID: {ident}")
+        except Exception as e:
+            logger.error(f"Error storing in SQLite: {e}")
+            return
+
+        # Store in vector database if enabled
+        if self.use_rag and hasattr(self, "chroma_col"):
+            try:
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))  # Ensure API key is correctly set
+                
+                logger.info("Getting embeddings from OpenAI...")
+                logger.debug(f"Embedding input text: {text}")  # Log the input text
+                
+                response = client.embeddings.create(
+                    input=text,
+                    model="text-embedding-3-small"
+                )
+                embedding = response.data[0].embedding
+                logger.info("Successfully got embeddings")
+                logger.debug(f"Received embedding of length: {len(embedding)}")  # Log embedding details
+                
+                # Sanitize metadata for ChromaDB
+                sanitized_metadata = self._sanitize_metadata(metadata)
+                
+                # Store in ChromaDB with embedding
+                self.chroma_col.add(
+                    documents=[text],
+                    metadatas=[sanitized_metadata],
+                    ids=[ident],
+                    embeddings=[embedding]
+                )
+                logger.info(f"Successfully stored in ChromaDB with ID: {ident}")
+            except Exception as e:
+                logger.error(f"Error storing in ChromaDB: {e}")
+        
+        elif self.use_mem0 and hasattr(self, "mem0_client"):
+            try:
+                self.mem0_client.add(text, metadata=metadata)
+                logger.info("Successfully stored in Mem0")
+            except Exception as e:
+                logger.error(f"Error storing in Mem0: {e}")
+
+
+    def search_long_term(
+        self, 
+        query: str, 
+        limit: int = 5, 
+        relevance_cutoff: float = 0.0,
+        min_quality: float = 0.0
+    ) -> List[Dict[str, Any]]:
+        """Search long-term memory with optional quality filter"""
+        self._log_verbose(f"Searching long memory for: {query}")
+        self._log_verbose(f"Min quality: {min_quality}")
+
+        found = []
+
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            results = self.mem0_client.search(query=query, limit=limit)
+            # Filter by quality
+            filtered = [r for r in results if r.get("metadata", {}).get("quality", 0.0) >= min_quality]
+            logger.info(f"Found {len(filtered)} results in Mem0")
+            return filtered
+
+        elif self.use_rag and hasattr(self, "chroma_col"):
+            try:
+                from openai import OpenAI
+                client = OpenAI()
+                
+                # Get query embedding
+                response = client.embeddings.create(
+                    input=query,
+                    model="text-embedding-3-small"  # Using consistent model
+                )
+                query_embedding = response.data[0].embedding
+                
+                # Search ChromaDB with embedding
+                resp = self.chroma_col.query(
+                    query_embeddings=[query_embedding],
+                    n_results=limit,
+                    include=["documents", "metadatas", "distances"]
+                )
+                
+                results = []
+                if resp["ids"]:
+                    for i in range(len(resp["ids"][0])):
+                        metadata = resp["metadatas"][0][i] if "metadatas" in resp else {}
+                        text = resp["documents"][0][i]
+                        # Add memory record citation
+                        text = f"{text} (Memory record: {text})"
+                        found.append({
+                            "id": resp["ids"][0][i],
+                            "text": text,
+                            "metadata": metadata,
+                            "score": 1.0 - (resp["distances"][0][i] if "distances" in resp else 0.0)
+                        })
+                logger.info(f"Found {len(found)} results in ChromaDB")
+
+            except Exception as e:
+                self._log_verbose(f"Error searching ChromaDB: {e}", logging.ERROR)
+
+        # Always try SQLite as fallback or additional source
+        conn = sqlite3.connect(self.long_db)
+        c = conn.cursor()
+        rows = c.execute(
+            "SELECT id, content, meta, created_at FROM long_mem WHERE content LIKE ? LIMIT ?",
+            (f"%{query}%", limit)
+        ).fetchall()
+        conn.close()
+
+        for row in rows:
+            meta = json.loads(row[2] or "{}")
+            text = row[1]
+            # Add memory record citation if not already present
+            if "(Memory record:" not in text:
+                text = f"{text} (Memory record: {text})"
+            # Only add if not already found by ChromaDB/Mem0
+            if not any(f["id"] == row[0] for f in found):
+                found.append({
+                    "id": row[0],
+                    "text": text,
+                    "metadata": meta,
+                    "created_at": row[3]
+                })
+        logger.info(f"Found {len(found)} total results after SQLite")
+
+        results = found
+
+        # Filter by quality if needed
+        if min_quality > 0:
+            self._log_verbose(f"Found {len(results)} initial results")
+            results = [
+                r for r in results 
+                if r.get("metadata", {}).get("quality", 0.0) >= min_quality
+            ]
+            self._log_verbose(f"After quality filter: {len(results)} results")
+
+        # Apply relevance cutoff if specified
+        if relevance_cutoff > 0:
+            results = [r for r in results if r.get("score", 1.0) >= relevance_cutoff]
+            logger.info(f"After relevance filter: {len(results)} results")
+        
+        return results[:limit]
+
+    def reset_long_term(self):
+        """Clear local LTM DB, plus Chroma or mem0 if in use."""
+        conn = sqlite3.connect(self.long_db)
+        conn.execute("DELETE FROM long_mem")
+        conn.commit()
+        conn.close()
+
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            # Mem0 has no universal reset API. Could implement partial or no-op.
+            pass
+        if self.use_rag and hasattr(self, "chroma_client"):
+            self.chroma_client.reset()  # entire DB
+            self._init_chroma()         # re-init fresh
+
+    # -------------------------------------------------------------------------
+    #                       Entity Memory Methods
+    # -------------------------------------------------------------------------
+    def store_entity(self, name: str, type_: str, desc: str, relations: str):
+        """
+        Save entity info in LTM (or mem0/rag). 
+        We'll label the metadata type = entity for easy filtering.
+        """
+        data = f"Entity {name}({type_}): {desc} | relationships: {relations}"
+        self.store_long_term(data, metadata={"category": "entity"})
+
+    def search_entity(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Filter to items that have metadata 'category=entity'.
+        """
+        all_hits = self.search_long_term(query, limit=20)  # gather more
+        ents = []
+        for h in all_hits:
+            meta = h.get("metadata") or {}
+            if meta.get("category") == "entity":
+                ents.append(h)
+        return ents[:limit]
+
+    def reset_entity_only(self):
+        """
+        If you only want to drop entity items from LTM, you'd do a custom 
+        delete from local DB where meta LIKE '%category=entity%'. 
+        For brevity, we do a full LTM reset here.
+        """
+        self.reset_long_term()
+
+    # -------------------------------------------------------------------------
+    #                       User Memory Methods
+    # -------------------------------------------------------------------------
+    def store_user_memory(self, user_id: str, text: str, extra: Dict[str, Any] = None):
+        """
+        If mem0 is used, do user-based addition. Otherwise store in LTM with user in metadata.
+        """
+        meta = {"user_id": user_id}
+        if extra:
+            meta.update(extra)
+
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            self.mem0_client.add(text, user_id=user_id, metadata=meta)
+        else:
+            self.store_long_term(text, metadata=meta)
+
+    def search_user_memory(self, user_id: str, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        If mem0 is used, pass user_id in. Otherwise fallback to local filter on user in metadata.
+        """
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            return self.mem0_client.search(query=query, limit=limit, user_id=user_id)
+        else:
+            hits = self.search_long_term(query, limit=20)
+            filtered = []
+            for h in hits:
+                meta = h.get("metadata", {})
+                if meta.get("user_id") == user_id:
+                    filtered.append(h)
+            return filtered[:limit]
+
+    def reset_user_memory(self):
+        """
+        Clear all user-based info. For simplicity, we do a full LTM reset. 
+        Real usage might filter only metadata "user_id".
+        """
+        self.reset_long_term()
+
+    # -------------------------------------------------------------------------
+    #                 Putting it all Together: Task Finalization
+    # -------------------------------------------------------------------------
+    def finalize_task_output(
+        self,
+        content: str,
+        agent_name: str,
+        quality_score: float,
+        threshold: float = 0.7,
+        metrics: Dict[str, Any] = None,
+        task_id: str = None
+    ):
+        """Store task output in memory with appropriate metadata"""
+        logger.info(f"Finalizing task output: {content[:100]}...")
+        logger.info(f"Agent: {agent_name}, Quality: {quality_score}, Threshold: {threshold}")
+        
+        metadata = {
+            "task_id": task_id,
+            "agent": agent_name,
+            "quality": quality_score,
+            "metrics": metrics,
+            "task_type": "output",
+            "stored_at": time.time()
+        }
+        logger.info(f"Prepared metadata: {metadata}")
+        
+        # Always store in short-term memory
+        try:
+            logger.info("Storing in short-term memory...")
+            self.store_short_term(
+                text=content,
+                metadata=metadata
+            )
+            logger.info("Successfully stored in short-term memory")
+        except Exception as e:
+            logger.error(f"Failed to store in short-term memory: {e}")
+        
+        # Store in long-term memory if quality meets threshold
+        if quality_score >= threshold:
+            try:
+                logger.info(f"Quality score {quality_score} >= {threshold}, storing in long-term memory...")
+                self.store_long_term(
+                    text=content,
+                    metadata=metadata
+                )
+                logger.info("Successfully stored in long-term memory")
+            except Exception as e:
+                logger.error(f"Failed to store in long-term memory: {e}")
+        else:
+            logger.info(f"Quality score {quality_score} < {threshold}, skipping long-term storage")
+
+    # -------------------------------------------------------------------------
+    #                 Building Context (Short, Long, Entities, User)
+    # -------------------------------------------------------------------------
+    def build_context_for_task(
+        self,
+        task_descr: str,
+        user_id: Optional[str] = None,
+        additional: str = "",
+        max_items: int = 3
+    ) -> str:
+        """
+        Merges relevant short-term, long-term, entity, user memories
+        into a single text block with deduplication and clean formatting.
+        """
+        q = (task_descr + " " + additional).strip()
+        lines = []
+        seen_contents = set()  # Track unique contents
+
+        def normalize_content(content: str) -> str:
+            """Normalize content for deduplication"""
+            # Extract just the main content without citations for comparison
+            normalized = content.split("(Memory record:")[0].strip()
+            # Keep more characters to reduce false duplicates
+            normalized = ''.join(c.lower() for c in normalized if not c.isspace())
+            return normalized
+
+        def format_content(content: str, max_len: int = 150) -> str:
+            """Format content with clean truncation at word boundaries"""
+            if not content:
+                return ""
+            
+            # Clean up content by removing extra whitespace and newlines
+            content = ' '.join(content.split())
+            
+            # If content contains a memory citation, preserve it
+            if "(Memory record:" in content:
+                return content  # Keep original citation format
+            
+            # Regular content truncation
+            if len(content) <= max_len:
+                return content
+            
+            truncate_at = content.rfind(' ', 0, max_len - 3)
+            if truncate_at == -1:
+                truncate_at = max_len - 3
+            return content[:truncate_at] + "..."
+
+        def add_section(title: str, hits: List[Any]) -> None:
+            """Add a section of memory hits with deduplication"""
+            if not hits:
+                return
+                
+            formatted_hits = []
+            for h in hits:
+                content = h.get('text', '') if isinstance(h, dict) else str(h)
+                if not content:
+                    continue
+                    
+                # Keep original format if it has a citation
+                if "(Memory record:" in content:
+                    formatted = content
+                else:
+                    formatted = format_content(content)
+                
+                # Only add if we haven't seen this normalized content before
+                normalized = normalize_content(formatted)
+                if normalized not in seen_contents:
+                    seen_contents.add(normalized)
+                    formatted_hits.append(formatted)
+            
+            if formatted_hits:
+                # Add section header
+                if lines:
+                    lines.append("")  # Space before new section
+                lines.append(title)
+                lines.append("=" * len(title))  # Underline the title
+                lines.append("")  # Space after title
+                
+                # Add formatted content with bullet points
+                for content in formatted_hits:
+                    lines.append(f" • {content}")
+
+        # Add each section
+        # First get all results
+        short_term = self.search_short_term(q, limit=max_items)
+        long_term = self.search_long_term(q, limit=max_items)
+        entities = self.search_entity(q, limit=max_items)
+        user_mem = self.search_user_memory(user_id, q, limit=max_items) if user_id else []
+
+        # Add sections in order of priority
+        add_section("Short-term Memory Context", short_term)
+        add_section("Long-term Memory Context", long_term)
+        add_section("Entity Context", entities)
+        if user_id:
+            add_section("User Context", user_mem)
+
+        return "\n".join(lines) if lines else ""
+
+    # -------------------------------------------------------------------------
+    #                      Master Reset (Everything)
+    # -------------------------------------------------------------------------
+    def reset_all(self):
+        """
+        Fully wipes short-term, long-term, and any memory in mem0 or rag.
+        """
+        self.reset_short_term()
+        self.reset_long_term()
+        # Entities & user memory are stored in LTM or mem0, so no separate step needed.
+
+    def _process_quality_metrics(
+        self,
+        metadata: Dict[str, Any],
+        completeness: float = None,
+        relevance: float = None,
+        clarity: float = None, 
+        accuracy: float = None,
+        weights: Dict[str, float] = None,
+        evaluator_quality: float = None
+    ) -> Dict[str, Any]:
+        """Process and store quality metrics in metadata"""
+        metadata = metadata or {}
+        
+        # Handle sub-metrics if provided
+        if None not in [completeness, relevance, clarity, accuracy]:
+            metadata.update({
+                "completeness": completeness,
+                "relevance": relevance,
+                "clarity": clarity,
+                "accuracy": accuracy,
+                "quality": self.compute_quality_score(
+                    completeness, relevance, clarity, accuracy, weights
+                )
+            })
+        # Handle external evaluator quality if provided
+        elif evaluator_quality is not None:
+            metadata["quality"] = evaluator_quality
+        
+        return metadata
+
+    def calculate_quality_metrics(
+        self,
+        output: str,
+        expected_output: str,
+        llm: Optional[str] = None,
+        custom_prompt: Optional[str] = None
+    ) -> Dict[str, float]:
+        """Calculate quality metrics using LLM"""
+        logger.info("Calculating quality metrics for output")
+        logger.info(f"Output: {output[:100]}...")
+        logger.info(f"Expected: {expected_output[:100]}...")
+        
+        # Default evaluation prompt
+        default_prompt = f"""
+        Evaluate the following output against expected output.
+        Score each metric from 0.0 to 1.0:
+        - Completeness: Does it address all requirements?
+        - Relevance: Does it match expected output?
+        - Clarity: Is it clear and well-structured?
+        - Accuracy: Is it factually correct?
+
+        Expected: {expected_output}
+        Actual: {output}
+
+        Return ONLY a JSON with these keys: completeness, relevance, clarity, accuracy
+        Example: {{"completeness": 0.95, "relevance": 0.8, "clarity": 0.9, "accuracy": 0.85}}
+        """
+
+        try:
+            # Use OpenAI client from main.py
+            from ..main import client
+            
+            response = client.chat.completions.create(
+                model=llm or "gpt-4o",
+                messages=[{
+                    "role": "user", 
+                    "content": custom_prompt or default_prompt
+                }],
+                response_format={"type": "json_object"},
+                temperature=0.3
+            )
+            
+            metrics = json.loads(response.choices[0].message.content)
+            
+            # Validate metrics
+            required = ["completeness", "relevance", "clarity", "accuracy"]
+            if not all(k in metrics for k in required):
+                raise ValueError("Missing required metrics in LLM response")
+            
+            logger.info(f"Calculated metrics: {metrics}")
+            return metrics
+            
+        except Exception as e:
+            logger.error(f"Error calculating metrics: {e}")
+            return {
+                "completeness": 0.0,
+                "relevance": 0.0,
+                "clarity": 0.0,
+                "accuracy": 0.0
+            }
+
+    def store_quality(
+        self,
+        text: str,
+        quality_score: float,
+        task_id: Optional[str] = None,
+        iteration: Optional[int] = None,
+        metrics: Optional[Dict[str, float]] = None,
+        memory_type: Literal["short", "long"] = "long"
+    ) -> None:
+        """Store quality metrics in memory"""
+        logger.info(f"Attempting to store in {memory_type} memory: {text[:100]}...")
+        
+        metadata = {
+            "quality": quality_score,
+            "task_id": task_id,
+            "iteration": iteration
+        }
+        
+        if metrics:
+            metadata.update({
+                k: v for k, v in metrics.items()  # Remove metric_ prefix
+            })
+            
+        logger.info(f"With metadata: {metadata}")
+        
+        try:
+            if memory_type == "short":
+                self.store_short_term(text, metadata=metadata)
+                logger.info("Successfully stored in short-term memory")
+            else:
+                self.store_long_term(text, metadata=metadata)
+                logger.info("Successfully stored in long-term memory")
+        except Exception as e:
+            logger.error(f"Failed to store in memory: {e}")
+
+    def search_with_quality(
+        self,
+        query: str,
+        min_quality: float = 0.0,
+        memory_type: Literal["short", "long"] = "long",
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Search with quality filter"""
+        logger.info(f"Searching {memory_type} memory for: {query}")
+        logger.info(f"Min quality: {min_quality}")
+        
+        search_func = (
+            self.search_short_term if memory_type == "short" 
+            else self.search_long_term
+        )
+        
+        results = search_func(query, limit=limit)
+        logger.info(f"Found {len(results)} initial results")
+        
+        filtered = [
+            r for r in results 
+            if r.get("metadata", {}).get("quality", 0.0) >= min_quality
+        ]
+        logger.info(f"After quality filter: {len(filtered)} results")
+        
+        return filtered

agents/praisonaiagents/process/__init__.py

@@ -0,0 +1,3 @@
+from .process import Process
+
+__all__ = ['Process'] 

agents/praisonaiagents/process/process.py

@@ -0,0 +1,569 @@
+import logging
+import asyncio
+from typing import Dict, Optional, List, Any, AsyncGenerator
+from pydantic import BaseModel
+from ..agent.agent import Agent
+from ..task.task import Task
+from ..main import display_error, client
+
+class LoopItems(BaseModel):
+    items: List[Any]
+
+class Process:
+    def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False, max_iter: int = 10):
+        self.tasks = tasks
+        self.agents = agents
+        self.manager_llm = manager_llm
+        self.verbose = verbose
+        self.max_iter = max_iter
+
+    async def aworkflow(self) -> AsyncGenerator[str, None]:
+        """Async version of workflow method"""
+        current_iter = 0  # Track how many times we've looped
+        # Build workflow relationships first
+        for task in self.tasks.values():
+            if task.next_tasks:
+                for next_task_name in task.next_tasks:
+                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                    if next_task:
+                        next_task.previous_tasks.append(task.name)
+
+        # Find start task
+        start_task = None
+        for task_id, task in self.tasks.items():
+            if task.is_start:
+                start_task = task
+                break
+        
+        if not start_task:
+            start_task = list(self.tasks.values())[0]
+            logging.info("No start task marked, using first task")
+        
+        current_task = start_task
+        visited_tasks = set()
+        loop_data = {}  # Store loop-specific data
+        
+        while current_task:
+            current_iter += 1
+            if current_iter > self.max_iter:
+                logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
+                break
+
+            task_id = current_task.id
+            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            
+            # Add context from previous tasks to description
+            if current_task.previous_tasks or current_task.context:
+                context = "\nInput data from previous tasks:"
+                
+                # Add data from previous tasks in workflow
+                for prev_name in current_task.previous_tasks:
+                    prev_task = next((t for t in self.tasks.values() if t.name == prev_name), None)
+                    if prev_task and prev_task.result:
+                        # Handle loop data
+                        if current_task.task_type == "loop":
+                            # create a loop manager Agent
+                            loop_manager = Agent(
+                                name="Loop Manager",
+                                role="Loop data processor",
+                                goal="Process loop data and convert it to list format",
+                                backstory="Expert at handling loop data and converting it to proper format",
+                                llm=self.manager_llm,
+                                verbose=self.verbose,
+                                markdown=True
+                            )
+
+                            # get the loop data convert it to list using calling Agent class chat
+                            loop_prompt = f"""
+Process this data into a list format:
+{prev_task.result.raw}
+
+Return a JSON object with an 'items' array containing the items to process.
+"""
+                            if current_task.async_execution:
+                                loop_data_str = await loop_manager.achat(
+                                    prompt=loop_prompt,
+                                    output_json=LoopItems
+                                )
+                            else:
+                                loop_data_str = loop_manager.chat(
+                                    prompt=loop_prompt,
+                                    output_json=LoopItems
+                                )
+                            
+                            try:
+                                # The response will already be parsed into LoopItems model
+                                loop_data[f"loop_{current_task.name}"] = {
+                                    "items": loop_data_str.items,
+                                    "index": 0,
+                                    "remaining": len(loop_data_str.items)
+                                }
+                                context += f"\nCurrent loop item: {loop_data_str.items[0]}"
+                            except Exception as e:
+                                display_error(f"Failed to process loop data: {e}")
+                                context += f"\n{prev_name}: {prev_task.result.raw}"
+                        else:
+                            context += f"\n{prev_name}: {prev_task.result.raw}"
+                
+                # Add data from context tasks
+                if current_task.context:
+                    for ctx_task in current_task.context:
+                        if ctx_task.result and ctx_task.name != current_task.name:
+                            context += f"\n{ctx_task.name}: {ctx_task.result.raw}"
+                
+                # Update task description with context
+                current_task.description = current_task.description + context
+            
+            # Execute task using existing run_task method
+            yield task_id
+            visited_tasks.add(task_id)
+            
+            # Reset completed task to "not started" so it can run again
+            if self.tasks[task_id].status == "completed":
+                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
+                self.tasks[task_id].status = "not started"
+            
+            # Handle loop progression
+            if current_task.task_type == "loop":
+                loop_key = f"loop_{current_task.name}"
+                if loop_key in loop_data:
+                    loop_info = loop_data[loop_key]
+                    loop_info["index"] += 1
+                    has_more = loop_info["remaining"] > 0
+                    
+                    # Update result to trigger correct condition
+                    if current_task.result:
+                        result = current_task.result.raw
+                        if has_more:
+                            result += "\nmore"
+                        else:
+                            result += "\ndone"
+                        current_task.result.raw = result
+                    
+            # Determine next task based on result
+            next_task = None
+            if current_task and current_task.result:
+                if current_task.task_type in ["decision", "loop"]:
+                    result = current_task.result.raw.lower()
+                    # Check conditions
+                    for condition, tasks in current_task.condition.items():
+                        if condition.lower() in result:
+                            # Handle both list and direct string values
+                            task_value = tasks[0] if isinstance(tasks, list) else tasks
+                            if not task_value or task_value == "exit":  # If empty or explicit exit
+                                logging.info("Workflow exit condition met, ending workflow")
+                                current_task = None
+                                break
+                            next_task_name = task_value
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            # For loops, allow revisiting the same task
+                            if next_task and next_task.id == current_task.id:
+                                visited_tasks.discard(current_task.id)
+                            break
+            
+            if not next_task and current_task and current_task.next_tasks:
+                next_task_name = current_task.next_tasks[0]
+                next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+            
+            current_task = next_task
+            if not current_task:
+                logging.info("Workflow execution completed")
+                break
+
+    async def asequential(self) -> AsyncGenerator[str, None]:
+        """Async version of sequential method"""
+        for task_id in self.tasks:
+            if self.tasks[task_id].status != "completed":
+                yield task_id
+
+    async def ahierarchical(self) -> AsyncGenerator[str, None]:
+        """Async version of hierarchical method"""
+        logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
+        manager_agent = Agent(
+            name="Manager",
+            role="Project manager",
+            goal="Manage the entire flow of tasks and delegate them to the right agent",
+            backstory="Expert project manager to coordinate tasks among agents",
+            llm=self.manager_llm,
+            verbose=self.verbose,
+            markdown=True,
+            self_reflect=False
+        )
+
+        class ManagerInstructions(BaseModel):
+            task_id: int
+            agent_name: str
+            action: str
+
+        manager_task = Task(
+            name="manager_task",
+            description="Decide the order of tasks and which agent executes them",
+            expected_output="All tasks completed successfully",
+            agent=manager_agent
+        )
+        manager_task_id = yield manager_task
+        logging.info(f"Created manager task with ID {manager_task_id}")
+
+        completed_count = 0
+        total_tasks = len(self.tasks) - 1
+        logging.info(f"Need to complete {total_tasks} tasks (excluding manager task)")
+
+        while completed_count < total_tasks:
+            tasks_summary = []
+            for tid, tk in self.tasks.items():
+                if tk.name == "manager_task":
+                    continue
+                task_info = {
+                    "task_id": tid,
+                    "name": tk.name,
+                    "description": tk.description,
+                    "status": tk.status if tk.status else "not started",
+                    "agent": tk.agent.name if tk.agent else "No agent"
+                }
+                tasks_summary.append(task_info)
+                logging.info(f"Task {tid} status: {task_info}")
+
+            manager_prompt = f"""
+Here is the current status of all tasks except yours (manager_task):
+{tasks_summary}
+
+Provide a JSON with the structure:
+{{
+   "task_id": <int>,
+   "agent_name": "<string>",
+   "action": "<execute or stop>"
+}}
+"""
+
+            try:
+                logging.info("Requesting manager instructions...")
+                if manager_task.async_execution:
+                    manager_response = await client.beta.chat.completions.parse(
+                        model=self.manager_llm,
+                        messages=[
+                            {"role": "system", "content": manager_task.description},
+                            {"role": "user", "content": manager_prompt}
+                        ],
+                        temperature=0.7,
+                        response_format=ManagerInstructions
+                    )
+                else:
+                    manager_response = client.beta.chat.completions.parse(
+                        model=self.manager_llm,
+                        messages=[
+                            {"role": "system", "content": manager_task.description},
+                            {"role": "user", "content": manager_prompt}
+                        ],
+                        temperature=0.7,
+                        response_format=ManagerInstructions
+                    )
+                parsed_instructions = manager_response.choices[0].message.parsed
+                logging.info(f"Manager instructions: {parsed_instructions}")
+            except Exception as e:
+                display_error(f"Manager parse error: {e}")
+                logging.error(f"Manager parse error: {str(e)}", exc_info=True)
+                break
+
+            selected_task_id = parsed_instructions.task_id
+            selected_agent_name = parsed_instructions.agent_name
+            action = parsed_instructions.action
+
+            logging.info(f"Manager selected task_id={selected_task_id}, agent={selected_agent_name}, action={action}")
+
+            if action.lower() == "stop":
+                logging.info("Manager decided to stop task execution")
+                break
+
+            if selected_task_id not in self.tasks:
+                error_msg = f"Manager selected invalid task id {selected_task_id}"
+                display_error(error_msg)
+                logging.error(error_msg)
+                break
+
+            original_agent = self.tasks[selected_task_id].agent.name if self.tasks[selected_task_id].agent else "None"
+            for a in self.agents:
+                if a.name == selected_agent_name:
+                    self.tasks[selected_task_id].agent = a
+                    logging.info(f"Changed agent for task {selected_task_id} from {original_agent} to {selected_agent_name}")
+                    break
+
+            if self.tasks[selected_task_id].status != "completed":
+                logging.info(f"Starting execution of task {selected_task_id}")
+                yield selected_task_id
+                logging.info(f"Finished execution of task {selected_task_id}, status: {self.tasks[selected_task_id].status}")
+
+            if self.tasks[selected_task_id].status == "completed":
+                completed_count += 1
+                logging.info(f"Task {selected_task_id} completed. Total completed: {completed_count}/{total_tasks}")
+
+        self.tasks[manager_task.id].status = "completed"
+        if self.verbose >= 1:
+            logging.info("All tasks completed under manager supervision.")
+        logging.info("Hierarchical task execution finished") 
+
+    def workflow(self):
+        """Synchronous version of workflow method"""
+        current_iter = 0  # Track how many times we've looped
+        # Build workflow relationships first
+        for task in self.tasks.values():
+            if task.next_tasks:
+                for next_task_name in task.next_tasks:
+                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                    if next_task:
+                        next_task.previous_tasks.append(task.name)
+
+        # Find start task
+        start_task = None
+        for task_id, task in self.tasks.items():
+            if task.is_start:
+                start_task = task
+                break
+        
+        if not start_task:
+            start_task = list(self.tasks.values())[0]
+            logging.info("No start task marked, using first task")
+        
+        current_task = start_task
+        visited_tasks = set()
+        loop_data = {}  # Store loop-specific data
+        
+        while current_task:
+            current_iter += 1
+            if current_iter > self.max_iter:
+                logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
+                break
+
+            task_id = current_task.id
+            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            
+            # Add context from previous tasks to description
+            if current_task.previous_tasks or current_task.context:
+                context = "\nInput data from previous tasks:"
+                
+                # Add data from previous tasks in workflow
+                for prev_name in current_task.previous_tasks:
+                    prev_task = next((t for t in self.tasks.values() if t.name == prev_name), None)
+                    if prev_task and prev_task.result:
+                        # Handle loop data
+                        if current_task.task_type == "loop":
+                            # create a loop manager Agent
+                            loop_manager = Agent(
+                                name="Loop Manager",
+                                role="Loop data processor",
+                                goal="Process loop data and convert it to list format",
+                                backstory="Expert at handling loop data and converting it to proper format",
+                                llm=self.manager_llm,
+                                verbose=self.verbose,
+                                markdown=True
+                            )
+
+                            # get the loop data convert it to list using calling Agent class chat
+                            loop_prompt = f"""
+Process this data into a list format:
+{prev_task.result.raw}
+
+Return a JSON object with an 'items' array containing the items to process.
+"""
+                            loop_data_str = loop_manager.chat(
+                                prompt=loop_prompt,
+                                output_json=LoopItems
+                            )
+                            
+                            try:
+                                # The response will already be parsed into LoopItems model
+                                loop_data[f"loop_{current_task.name}"] = {
+                                    "items": loop_data_str.items,
+                                    "index": 0,
+                                    "remaining": len(loop_data_str.items)
+                                }
+                                context += f"\nCurrent loop item: {loop_data_str.items[0]}"
+                            except Exception as e:
+                                display_error(f"Failed to process loop data: {e}")
+                                context += f"\n{prev_name}: {prev_task.result.raw}"
+                        else:
+                            context += f"\n{prev_name}: {prev_task.result.raw}"
+                
+                # Add data from context tasks
+                if current_task.context:
+                    for ctx_task in current_task.context:
+                        if ctx_task.result and ctx_task.name != current_task.name:
+                            context += f"\n{ctx_task.name}: {ctx_task.result.raw}"
+                
+                # Update task description with context
+                current_task.description = current_task.description + context
+            
+            # Execute task using existing run_task method
+            yield task_id
+            visited_tasks.add(task_id)
+            
+            # Reset completed task to "not started" so it can run again
+            if self.tasks[task_id].status == "completed":
+                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
+                self.tasks[task_id].status = "not started"
+            
+            # Handle loop progression
+            if current_task.task_type == "loop":
+                loop_key = f"loop_{current_task.name}"
+                if loop_key in loop_data:
+                    loop_info = loop_data[loop_key]
+                    loop_info["index"] += 1
+                    has_more = loop_info["remaining"] > 0
+                    
+                    # Update result to trigger correct condition
+                    if current_task.result:
+                        result = current_task.result.raw
+                        if has_more:
+                            result += "\nmore"
+                        else:
+                            result += "\ndone"
+                        current_task.result.raw = result
+                    
+            # Determine next task based on result
+            next_task = None
+            if current_task and current_task.result:
+                if current_task.task_type in ["decision", "loop"]:
+                    result = current_task.result.raw.lower()
+                    # Check conditions
+                    for condition, tasks in current_task.condition.items():
+                        if condition.lower() in result:
+                            # Handle both list and direct string values
+                            task_value = tasks[0] if isinstance(tasks, list) else tasks
+                            if not task_value or task_value == "exit":  # If empty or explicit exit
+                                logging.info("Workflow exit condition met, ending workflow")
+                                current_task = None
+                                break
+                            next_task_name = task_value
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            # For loops, allow revisiting the same task
+                            if next_task and next_task.id == current_task.id:
+                                visited_tasks.discard(current_task.id)
+                            break
+            
+            if not next_task and current_task and current_task.next_tasks:
+                next_task_name = current_task.next_tasks[0]
+                next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+            
+            current_task = next_task
+            if not current_task:
+                logging.info("Workflow execution completed")
+                break
+
+    def sequential(self):
+        """Synchronous version of sequential method"""
+        for task_id in self.tasks:
+            if self.tasks[task_id].status != "completed":
+                yield task_id
+
+    def hierarchical(self):
+        """Synchronous version of hierarchical method"""
+        logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
+        manager_agent = Agent(
+            name="Manager",
+            role="Project manager",
+            goal="Manage the entire flow of tasks and delegate them to the right agent",
+            backstory="Expert project manager to coordinate tasks among agents",
+            llm=self.manager_llm,
+            verbose=self.verbose,
+            markdown=True,
+            self_reflect=False
+        )
+
+        class ManagerInstructions(BaseModel):
+            task_id: int
+            agent_name: str
+            action: str
+
+        manager_task = Task(
+            name="manager_task",
+            description="Decide the order of tasks and which agent executes them",
+            expected_output="All tasks completed successfully",
+            agent=manager_agent
+        )
+        manager_task_id = yield manager_task
+        logging.info(f"Created manager task with ID {manager_task_id}")
+
+        completed_count = 0
+        total_tasks = len(self.tasks) - 1
+        logging.info(f"Need to complete {total_tasks} tasks (excluding manager task)")
+
+        while completed_count < total_tasks:
+            tasks_summary = []
+            for tid, tk in self.tasks.items():
+                if tk.name == "manager_task":
+                    continue
+                task_info = {
+                    "task_id": tid,
+                    "name": tk.name,
+                    "description": tk.description,
+                    "status": tk.status if tk.status else "not started",
+                    "agent": tk.agent.name if tk.agent else "No agent"
+                }
+                tasks_summary.append(task_info)
+                logging.info(f"Task {tid} status: {task_info}")
+
+            manager_prompt = f"""
+Here is the current status of all tasks except yours (manager_task):
+{tasks_summary}
+
+Provide a JSON with the structure:
+{{
+   "task_id": <int>,
+   "agent_name": "<string>",
+   "action": "<execute or stop>"
+}}
+"""
+
+            try:
+                logging.info("Requesting manager instructions...")
+                manager_response = client.beta.chat.completions.parse(
+                    model=self.manager_llm,
+                    messages=[
+                        {"role": "system", "content": manager_task.description},
+                        {"role": "user", "content": manager_prompt}
+                    ],
+                    temperature=0.7,
+                    response_format=ManagerInstructions
+                )
+                parsed_instructions = manager_response.choices[0].message.parsed
+                logging.info(f"Manager instructions: {parsed_instructions}")
+            except Exception as e:
+                display_error(f"Manager parse error: {e}")
+                logging.error(f"Manager parse error: {str(e)}", exc_info=True)
+                break
+
+            selected_task_id = parsed_instructions.task_id
+            selected_agent_name = parsed_instructions.agent_name
+            action = parsed_instructions.action
+
+            logging.info(f"Manager selected task_id={selected_task_id}, agent={selected_agent_name}, action={action}")
+
+            if action.lower() == "stop":
+                logging.info("Manager decided to stop task execution")
+                break
+
+            if selected_task_id not in self.tasks:
+                error_msg = f"Manager selected invalid task id {selected_task_id}"
+                display_error(error_msg)
+                logging.error(error_msg)
+                break
+
+            original_agent = self.tasks[selected_task_id].agent.name if self.tasks[selected_task_id].agent else "None"
+            for a in self.agents:
+                if a.name == selected_agent_name:
+                    self.tasks[selected_task_id].agent = a
+                    logging.info(f"Changed agent for task {selected_task_id} from {original_agent} to {selected_agent_name}")
+                    break
+
+            if self.tasks[selected_task_id].status != "completed":
+                logging.info(f"Starting execution of task {selected_task_id}")
+                yield selected_task_id
+                logging.info(f"Finished execution of task {selected_task_id}, status: {self.tasks[selected_task_id].status}")
+
+            if self.tasks[selected_task_id].status == "completed":
+                completed_count += 1
+                logging.info(f"Task {selected_task_id} completed. Total completed: {completed_count}/{total_tasks}")
+
+        self.tasks[manager_task.id].status = "completed"
+        if self.verbose >= 1:
+            logging.info("All tasks completed under manager supervision.")
+        logging.info("Hierarchical task execution finished") 

agents/praisonaiagents/task/__init__.py

@@ -0,0 +1,4 @@
+"""Task module for AI agent tasks"""
+from .task import Task
+
+__all__ = ['Task'] 

agents/praisonaiagents/task/task.py

@@ -0,0 +1,222 @@
+import logging
+import asyncio
+from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine
+from pydantic import BaseModel
+from ..main import TaskOutput
+from ..agent.agent import Agent
+import uuid
+import os
+import time
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+class Task:
+    def __init__(
+        self,
+        description: str,
+        expected_output: Optional[str] = None,
+        agent: Optional[Agent] = None,
+        name: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
+        context: Optional[List["Task"]] = None,
+        async_execution: Optional[bool] = False,
+        config: Optional[Dict[str, Any]] = None,
+        output_file: Optional[str] = None,
+        output_json: Optional[Type[BaseModel]] = None,
+        output_pydantic: Optional[Type[BaseModel]] = None,
+        callback: Optional[Union[Callable[[TaskOutput], Any], Callable[[TaskOutput], Coroutine[Any, Any, Any]]]] = None,
+        status: str = "not started",
+        result: Optional[TaskOutput] = None,
+        create_directory: Optional[bool] = False,
+        id: Optional[int] = None,
+        images: Optional[List[str]] = None,
+        next_tasks: Optional[List[str]] = None,
+        task_type: str = "task",
+        condition: Optional[Dict[str, List[str]]] = None,
+        is_start: bool = False,
+        loop_state: Optional[Dict[str, Union[str, int]]] = None,
+        memory=None,
+        quality_check=True
+    ):
+        self.id = str(uuid.uuid4()) if id is None else str(id)
+        self.name = name
+        self.description = description
+        self.expected_output = expected_output if expected_output is not None else "Complete the task successfully"
+        self.agent = agent
+        self.tools = tools if tools else []
+        self.context = context if context else []
+        self.async_execution = async_execution
+        self.config = config if config else {}
+        self.output_file = output_file
+        self.output_json = output_json
+        self.output_pydantic = output_pydantic
+        self.callback = callback
+        self.status = status
+        self.result = result
+        self.create_directory = create_directory
+        self.images = images if images else []
+        self.next_tasks = next_tasks if next_tasks else []
+        self.task_type = task_type
+        self.condition = condition if condition else {}
+        self.is_start = is_start
+        self.loop_state = loop_state if loop_state else {}
+        self.memory = memory
+        self.quality_check = quality_check
+
+        # Set logger level based on config verbose level
+        verbose = self.config.get("verbose", 0)
+        if verbose >= 5:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+            
+        # Also set third-party loggers to WARNING
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('openai').setLevel(logging.WARNING)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+
+        if self.output_json and self.output_pydantic:
+            raise ValueError("Only one output type can be defined")
+
+        # Track previous tasks based on next_tasks relationships
+        self.previous_tasks = []
+
+    def __str__(self):
+        return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
+
+    def initialize_memory(self):
+        """Initialize memory if config exists but memory doesn't"""
+        if not self.memory and self.config.get('memory_config'):
+            try:
+                from ..memory.memory import Memory
+                logger.info(f"Task {self.id}: Initializing memory from config: {self.config['memory_config']}")
+                self.memory = Memory(config=self.config['memory_config'])
+                logger.info(f"Task {self.id}: Memory initialized successfully")
+                
+                # Verify database was created
+                if os.path.exists(self.config['memory_config']['storage']['path']):
+                    logger.info(f"Task {self.id}: Memory database exists after initialization")
+                else:
+                    logger.error(f"Task {self.id}: Failed to create memory database!")
+                return self.memory
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to initialize memory: {e}")
+                logger.exception(e)
+        return None
+
+    def store_in_memory(self, content: str, agent_name: str = None, task_id: str = None):
+        """Store content in memory with metadata"""
+        if self.memory:
+            try:
+                logger.info(f"Task {self.id}: Storing content in memory...")
+                self.memory.store_long_term(
+                    text=content,
+                    metadata={
+                        "agent_name": agent_name or "Agent",
+                        "task_id": task_id or self.id,
+                        "timestamp": time.time()
+                    }
+                )
+                logger.info(f"Task {self.id}: Content stored in memory")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to store content in memory: {e}")
+                logger.exception(e)
+
+    async def execute_callback(self, task_output: TaskOutput) -> None:
+        """Execute callback and store quality metrics if enabled"""
+        logger.info(f"Task {self.id}: execute_callback called")
+        logger.info(f"Quality check enabled: {self.quality_check}")
+        
+        # Initialize memory if not already initialized
+        if not self.memory:
+            self.memory = self.initialize_memory()
+        
+        logger.info(f"Memory object exists: {self.memory is not None}")
+        if self.memory:
+            logger.info(f"Memory config: {self.memory.cfg}")
+            # Store task output in memory
+            try:
+                logger.info(f"Task {self.id}: Storing task output in memory...")
+                self.store_in_memory(
+                    content=task_output.raw,
+                    agent_name=self.agent.name if self.agent else "Agent",
+                    task_id=self.id
+                )
+                logger.info(f"Task {self.id}: Task output stored in memory")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to store task output in memory: {e}")
+                logger.exception(e)
+        
+        logger.info(f"Task output: {task_output.raw[:100]}...")
+        
+        if self.quality_check and self.memory:
+            try:
+                logger.info(f"Task {self.id}: Starting memory operations")
+                logger.info(f"Task {self.id}: Calculating quality metrics for output: {task_output.raw[:100]}...")
+                
+                # Get quality metrics from LLM
+                metrics = self.memory.calculate_quality_metrics(
+                    task_output.raw,
+                    self.expected_output
+                )
+                logger.info(f"Task {self.id}: Quality metrics calculated: {metrics}")
+                
+                quality_score = metrics.get("accuracy", 0.0)
+                logger.info(f"Task {self.id}: Quality score: {quality_score}")
+                
+                # Store in both short and long-term memory with higher threshold
+                logger.info(f"Task {self.id}: Finalizing task output in memory...")
+                self.memory.finalize_task_output(
+                    content=task_output.raw,
+                    agent_name=self.agent.name if self.agent else "Agent",
+                    quality_score=quality_score,
+                    threshold=0.7,  # Only high quality outputs in long-term memory
+                    metrics=metrics,
+                    task_id=self.id
+                )
+                logger.info(f"Task {self.id}: Finalized task output in memory")
+                
+                # Store quality metrics separately
+                logger.info(f"Task {self.id}: Storing quality metrics...")
+                self.memory.store_quality(
+                    text=task_output.raw,
+                    quality_score=quality_score,
+                    task_id=self.id,
+                    metrics=metrics
+                )
+                
+                # Store in both short and long-term memory with higher threshold
+                self.memory.finalize_task_output(
+                    content=task_output.raw,
+                    agent_name=self.agent.name if self.agent else "Agent",
+                    quality_score=quality_score,
+                    threshold=0.7  # Only high quality outputs in long-term memory
+                )
+                
+                # Build context for next tasks
+                if self.next_tasks:
+                    logger.info(f"Task {self.id}: Building context for next tasks...")
+                    context = self.memory.build_context_for_task(
+                        task_descr=task_output.raw,
+                        max_items=5
+                    )
+                    logger.info(f"Task {self.id}: Built context for next tasks: {len(context)} items")
+                
+                logger.info(f"Task {self.id}: Memory operations complete")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to process memory operations: {e}")
+                logger.exception(e)  # Print full stack trace
+                # Continue execution even if memory operations fail
+
+        # Execute original callback
+        if self.callback:
+            try:
+                if asyncio.iscoroutinefunction(self.callback):
+                    await self.callback(task_output)
+                else:
+                    self.callback(task_output)
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to execute callback: {e}")
+                logger.exception(e)

agents/praisonaiagents/tools/README.md

@@ -0,0 +1,149 @@
+# PraisonAI Tools Guide
+
+Welcome to the PraisonAI Tools directory! This guide will help you understand how our tools work and how to create new ones, whether you're a beginner or an experienced programmer.
+
+## What is a Tool?
+
+A tool is a piece of code that helps our AI agents perform specific tasks. Think of tools as special abilities that we give to our agents. For example:
+- An internet search tool lets agents search the web
+- A stock market tool lets agents check stock prices
+- A weather tool lets agents check the weather
+
+## Creating New Tools: The Two Approaches
+
+### 1. Function-Based Approach (Simple Tools)
+
+Best for simple tools that do one specific thing. Like a calculator that just adds numbers.
+
+**When to use:**
+- Tool does one simple task
+- Doesn't need to remember information between uses
+- Doesn't need to share information with other tools
+- Quick, one-time operations
+
+**Example:**
+```python
+def internet_search(query: str):
+    # Search the internet and return results
+    return search_results
+```
+
+**Usage:**
+```python
+from praisonaiagents.tools import internet_search
+
+results = internet_search("AI news")
+```
+
+### 2. Class-Based Approach (Complex Tools)
+
+Best for tools that do multiple related things or need to remember information. Like a smart calculator that remembers your previous calculations and can do many different math operations.
+
+**When to use:**
+- Tool has multiple related functions
+- Needs to remember or share information
+- Needs to manage resources efficiently
+- Has complex setup requirements
+
+**Example:**
+```python
+class StockTools:
+    def get_stock_price(self, symbol):
+        # Get current stock price
+        return price
+        
+    def get_stock_info(self, symbol):
+        # Get detailed stock information
+        return info
+```
+
+**Usage:**
+```python
+from praisonaiagents.tools import get_stock_price, get_stock_info
+
+price = get_stock_price("AAPL")
+info = get_stock_info("AAPL")
+```
+
+## How to Choose Your Approach
+
+Ask yourself these questions:
+
+1. **Is your tool doing one simple thing?**
+   - Yes → Use Function-Based Approach
+   - No → Consider Class-Based Approach
+
+2. **Does your tool need to remember information?**
+   - Yes → Use Class-Based Approach
+   - No → Use Function-Based Approach
+
+3. **Are your tool's operations related to each other?**
+   - Yes → Use Class-Based Approach
+   - No → Use Function-Based Approach
+
+4. **Does your tool need to manage resources efficiently?**
+   - Yes → Use Class-Based Approach
+   - No → Use Function-Based Approach
+
+## Real-World Examples
+
+### Internet Search Tool (Function-Based)
+- Does one thing: searches the internet
+- Doesn't need to remember previous searches
+- Each search is independent
+- Simple input/output operation
+
+### Stock Market Tool (Class-Based)
+- Does multiple things: check prices, get company info, get historical data
+- Remembers stock information to avoid repeated downloads
+- Operations are related (all about stocks)
+- Manages connections efficiently
+
+## Getting Started
+
+1. **Choose Your Approach** based on the guidelines above
+
+2. **Create Your Tool File**:
+   - Name it descriptively (e.g., `weather_tools.py`)
+   - Place it in the `praisonaiagents/tools` directory
+
+3. **Write Your Tool**:
+   - Add clear documentation
+   - Include type hints for better understanding
+   - Handle errors gracefully
+
+4. **Test Your Tool**:
+   - Make sure it works as expected
+   - Test error cases
+   - Check performance
+
+## Best Practices
+
+1. **Documentation**:
+   - Explain what your tool does
+   - Provide examples
+   - List any requirements
+
+2. **Error Handling**:
+   - Always handle possible errors
+   - Return helpful error messages
+   - Don't let your tool crash
+
+3. **Performance**:
+   - Keep it efficient
+   - Don't waste resources
+   - Cache when helpful
+
+4. **User-Friendly**:
+   - Make it easy to use
+   - Use clear function/method names
+   - Keep it simple
+
+## Need Help?
+
+- Check existing tools for examples
+- Ask in our community
+- Read the documentation
+- Don't hesitate to ask questions!
+
+Remember: The goal is to make tools that are easy to use and maintain. Choose the approach that makes the most sense for your specific tool's needs.

agents/praisonaiagents/tools/__init__.py

@@ -0,0 +1,178 @@
+"""Tools package for PraisonAI Agents"""
+from importlib import import_module
+from typing import Any
+
+# Map of function names to their module and class (if any)
+TOOL_MAPPINGS = {
+    # Direct functions
+    'internet_search': ('.duckduckgo_tools', None),
+    'duckduckgo': ('.duckduckgo_tools', None),
+    
+    # arXiv Tools
+    'search_arxiv': ('.arxiv_tools', None),
+    'get_arxiv_paper': ('.arxiv_tools', None),
+    'get_papers_by_author': ('.arxiv_tools', None),
+    'get_papers_by_category': ('.arxiv_tools', None),
+    'arxiv_tools': ('.arxiv_tools', None),
+    
+    # Wikipedia Tools
+    'wiki_search': ('.wikipedia_tools', None),
+    'wiki_summary': ('.wikipedia_tools', None),
+    'wiki_page': ('.wikipedia_tools', None),
+    'wiki_random': ('.wikipedia_tools', None),
+    'wiki_language': ('.wikipedia_tools', None),
+    'wikipedia_tools': ('.wikipedia_tools', None),
+    
+    # Newspaper Tools
+    'get_article': ('.newspaper_tools', None),
+    'get_news_sources': ('.newspaper_tools', None),
+    'get_articles_from_source': ('.newspaper_tools', None),
+    'get_trending_topics': ('.newspaper_tools', None),
+    'newspaper_tools': ('.newspaper_tools', None),
+    
+    # Spider Tools
+    'scrape_page': ('.spider_tools', None),
+    'extract_links': ('.spider_tools', None),
+    'crawl': ('.spider_tools', None),
+    'extract_text': ('.spider_tools', None),
+    'spider_tools': ('.spider_tools', None),
+    
+    # DuckDB Tools
+    'query': ('.duckdb_tools', None),
+    'create_table': ('.duckdb_tools', None),
+    'load_data': ('.duckdb_tools', None),
+    'export_data': ('.duckdb_tools', None),
+    'get_table_info': ('.duckdb_tools', None),
+    'analyze_data': ('.duckdb_tools', None),
+    'duckdb_tools': ('.duckdb_tools', None),
+    
+    # Shell Tools
+    'execute_command': ('.shell_tools', None),
+    'list_processes': ('.shell_tools', None),
+    'kill_process': ('.shell_tools', None),
+    'get_system_info': ('.shell_tools', None),
+    'shell_tools': ('.shell_tools', None),
+
+    # Calculator Tools
+    'evaluate': ('.calculator_tools', None),
+    'solve_equation': ('.calculator_tools', None),
+    'convert_units': ('.calculator_tools', None),
+    'calculate_statistics': ('.calculator_tools', None),
+    'calculate_financial': ('.calculator_tools', None),
+    'calculator_tools': ('.calculator_tools', None),
+
+    # Class methods from YFinance
+    'get_stock_price': ('.yfinance_tools', 'YFinanceTools'),
+    'get_stock_info': ('.yfinance_tools', 'YFinanceTools'),
+    'get_historical_data': ('.yfinance_tools', 'YFinanceTools'),
+    'yfinance': ('.yfinance_tools', 'YFinanceTools'),
+
+    # File Tools
+    'read_file': ('.file_tools', 'FileTools'),
+    'write_file': ('.file_tools', 'FileTools'),
+    'list_files': ('.file_tools', 'FileTools'),
+    'get_file_info': ('.file_tools', 'FileTools'),
+    'copy_file': ('.file_tools', 'FileTools'),
+    'move_file': ('.file_tools', 'FileTools'),
+    'delete_file': ('.file_tools', 'FileTools'),
+    'file_tools': ('.file_tools', 'FileTools'),
+
+    # CSV Tools
+    'read_csv': ('.csv_tools', 'CSVTools'),
+    'write_csv': ('.csv_tools', 'CSVTools'),
+    'merge_csv': ('.csv_tools', 'CSVTools'),
+    'analyze_csv': ('.csv_tools', 'CSVTools'),
+    'split_csv': ('.csv_tools', 'CSVTools'),
+    'csv_tools': ('.csv_tools', 'CSVTools'),
+
+    # JSON Tools
+    'read_json': ('.json_tools', 'JSONTools'),
+    'write_json': ('.json_tools', 'JSONTools'),
+    'merge_json': ('.json_tools', 'JSONTools'),
+    'validate_json': ('.json_tools', 'JSONTools'),
+    'analyze_json': ('.json_tools', 'JSONTools'),
+    'transform_json': ('.json_tools', 'JSONTools'),
+    'json_tools': ('.json_tools', 'JSONTools'),
+
+    # Excel Tools
+    'read_excel': ('.excel_tools', 'ExcelTools'),
+    'write_excel': ('.excel_tools', 'ExcelTools'),
+    'merge_excel': ('.excel_tools', 'ExcelTools'),
+    'create_chart': ('.excel_tools', 'ExcelTools'),
+    'add_chart_to_sheet': ('.excel_tools', 'ExcelTools'),
+    'excel_tools': ('.excel_tools', 'ExcelTools'),
+
+    # XML Tools
+    'read_xml': ('.xml_tools', 'XMLTools'),
+    'write_xml': ('.xml_tools', 'XMLTools'),
+    'transform_xml': ('.xml_tools', 'XMLTools'),
+    'validate_xml': ('.xml_tools', 'XMLTools'),
+    'xml_to_dict': ('.xml_tools', 'XMLTools'),
+    'dict_to_xml': ('.xml_tools', 'XMLTools'),
+    'xpath_query': ('.xml_tools', 'XMLTools'),
+    'xml_tools': ('.xml_tools', 'XMLTools'),
+
+    # YAML Tools
+    'read_yaml': ('.yaml_tools', 'YAMLTools'),
+    'write_yaml': ('.yaml_tools', 'YAMLTools'),
+    'merge_yaml': ('.yaml_tools', 'YAMLTools'),
+    'validate_yaml': ('.yaml_tools', 'YAMLTools'),
+    'analyze_yaml': ('.yaml_tools', 'YAMLTools'),
+    'transform_yaml': ('.yaml_tools', 'YAMLTools'),
+    'yaml_tools': ('.yaml_tools', 'YAMLTools'),
+
+    # Python Tools
+    'execute_code': ('.python_tools', 'PythonTools'),
+    'analyze_code': ('.python_tools', 'PythonTools'),
+    'format_code': ('.python_tools', 'PythonTools'),
+    'lint_code': ('.python_tools', 'PythonTools'),
+    'disassemble_code': ('.python_tools', 'PythonTools'),
+    'python_tools': ('.python_tools', 'PythonTools'),
+
+    # Pandas Tools
+    'filter_data': ('.pandas_tools', 'PandasTools'),
+    'get_summary': ('.pandas_tools', 'PandasTools'),
+    'group_by': ('.pandas_tools', 'PandasTools'),
+    'pivot_table': ('.pandas_tools', 'PandasTools'),
+    'pandas_tools': ('.pandas_tools', 'PandasTools'),
+}
+
+_instances = {}  # Cache for class instances
+
+def __getattr__(name: str) -> Any:
+    """Smart lazy loading of tools with class method support."""
+    if name not in TOOL_MAPPINGS:
+        raise AttributeError(f"module '{__package__}' has no attribute '{name}'")
+    
+    module_path, class_name = TOOL_MAPPINGS[name]
+    
+    if class_name is None:
+        # Direct function import
+        module = import_module(module_path, __package__)
+        if name in [
+            'duckduckgo', 'internet_search',
+            'search_arxiv', 'get_arxiv_paper', 'get_papers_by_author', 'get_papers_by_category',
+            'wiki_search', 'wiki_summary', 'wiki_page', 'wiki_random', 'wiki_language',
+            'get_article', 'get_news_sources', 'get_articles_from_source', 'get_trending_topics',
+            'scrape_page', 'extract_links', 'crawl', 'extract_text',
+            'query', 'create_table', 'load_data', 'export_data', 'get_table_info', 'analyze_data',
+            'execute_command', 'list_processes', 'kill_process', 'get_system_info',
+            'evaluate', 'solve_equation', 'convert_units', 'calculate_statistics', 'calculate_financial'
+        ]:
+            return getattr(module, name)
+        if name in ['file_tools', 'pandas_tools', 'wikipedia_tools',
+                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools']:
+            return module  # Returns the callable module
+        return getattr(module, name)
+    else:
+        # Class method import
+        if class_name not in _instances:
+            module = import_module(module_path, __package__)
+            class_ = getattr(module, class_name)
+            _instances[class_name] = class_()
+        
+        # Get the method and bind it to the instance
+        method = getattr(_instances[class_name], name)
+        return method
+
+__all__ = list(TOOL_MAPPINGS.keys())

agents/praisonaiagents/tools/arxiv_tools.py

@@ -0,0 +1,292 @@
+"""Tools for searching and retrieving papers from arXiv.
+
+Usage:
+from praisonaiagents.tools import arxiv_tools
+papers = arxiv_tools.search("quantum computing")
+paper = arxiv_tools.get_paper("2401.00123")
+
+or
+from praisonaiagents.tools import search_arxiv, get_arxiv_paper
+papers = search_arxiv("quantum computing")
+"""
+
+import logging
+from typing import List, Dict, Union, Optional, Any
+from importlib import util
+import json
+
+# Map sort criteria to arxiv.SortCriterion
+SORT_CRITERIA = {
+    "relevance": "Relevance",
+    "lastupdateddate": "LastUpdatedDate",
+    "submitteddate": "SubmittedDate"
+}
+
+# Map sort order to arxiv.SortOrder
+SORT_ORDER = {
+    "ascending": "Ascending",
+    "descending": "Descending"
+}
+
+class ArxivTools:
+    """Tools for searching and retrieving papers from arXiv."""
+    
+    def __init__(self):
+        """Initialize ArxivTools and check for arxiv package."""
+        self._check_arxiv()
+        
+    def _check_arxiv(self):
+        """Check if arxiv package is installed."""
+        if util.find_spec("arxiv") is None:
+            raise ImportError("arxiv package is not available. Please install it using: pip install arxiv")
+        global arxiv
+        import arxiv
+
+    def search(
+        self,
+        query: str,
+        max_results: int = 10,
+        sort_by: str = "relevance",
+        sort_order: str = "descending",
+        include_fields: Optional[List[str]] = None
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """
+        Search arXiv for papers matching the query.
+        
+        Args:
+            query: Search query (e.g., "quantum computing", "author:Einstein")
+            max_results: Maximum number of results to return
+            sort_by: Sort results by ("relevance", "lastUpdatedDate", "submittedDate")
+            sort_order: Sort order ("ascending" or "descending")
+            include_fields: List of fields to include in results. If None, includes all.
+                Available fields: ["title", "authors", "summary", "comment", "journal_ref",
+                "doi", "primary_category", "categories", "links"]
+            
+        Returns:
+            List[Dict] or Dict: List of papers or error dict
+        """
+        try:
+            import arxiv
+            
+            # Configure search client
+            client = arxiv.Client()
+            
+            # Map sort criteria
+            sort_by_enum = getattr(arxiv.SortCriterion, SORT_CRITERIA[sort_by.lower()])
+            sort_order_enum = getattr(arxiv.SortOrder, SORT_ORDER[sort_order.lower()])
+            
+            # Build search query
+            search = arxiv.Search(
+                query=query,
+                max_results=max_results,
+                sort_by=sort_by_enum,
+                sort_order=sort_order_enum
+            )
+            
+            # Execute search
+            results = []
+            for result in client.results(search):
+                # Convert to dict with selected fields
+                paper = self._result_to_dict(result, include_fields)
+                results.append(paper)
+            
+            return results
+        except Exception as e:
+            error_msg = f"Error searching arXiv: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def get_paper(
+        self,
+        paper_id: str,
+        include_fields: Optional[List[str]] = None
+    ) -> Union[Dict[str, Any], Dict[str, str]]:
+        """
+        Get details of a specific paper by its arXiv ID.
+        
+        Args:
+            paper_id: arXiv paper ID (e.g., "2401.00123")
+            include_fields: List of fields to include in results. If None, includes all.
+                Available fields: ["title", "authors", "summary", "comment", "journal_ref",
+                "doi", "primary_category", "categories", "links"]
+            
+        Returns:
+            Dict: Paper details or error dict
+        """
+        try:
+            import arxiv
+            
+            # Configure client
+            client = arxiv.Client()
+            
+            # Get paper by ID
+            search = arxiv.Search(id_list=[paper_id])
+            results = list(client.results(search))
+            
+            if not results:
+                return {"error": f"Paper with ID {paper_id} not found"}
+            
+            # Convert to dict with selected fields
+            paper = self._result_to_dict(results[0], include_fields)
+            return paper
+        except Exception as e:
+            error_msg = f"Error getting paper {paper_id}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def get_papers_by_author(
+        self,
+        author: str,
+        max_results: int = 10,
+        sort_by: str = "submittedDate",
+        sort_order: str = "descending",
+        include_fields: Optional[List[str]] = None
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """
+        Get papers by a specific author.
+        
+        Args:
+            author: Author name (e.g., "Einstein")
+            max_results: Maximum number of results to return
+            sort_by: Sort results by ("relevance", "lastUpdatedDate", "submittedDate")
+            sort_order: Sort order ("ascending" or "descending")
+            include_fields: List of fields to include in results
+            
+        Returns:
+            List[Dict] or Dict: List of papers or error dict
+        """
+        query = f'au:"{author}"'
+        return self.search(query, max_results, sort_by, sort_order, include_fields)
+
+    def get_papers_by_category(
+        self,
+        category: str,
+        max_results: int = 10,
+        sort_by: str = "submittedDate",
+        sort_order: str = "descending",
+        include_fields: Optional[List[str]] = None
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """
+        Get papers from a specific category.
+        
+        Args:
+            category: arXiv category (e.g., "cs.AI", "physics.gen-ph")
+            max_results: Maximum number of results to return
+            sort_by: Sort results by ("relevance", "lastUpdatedDate", "submittedDate")
+            sort_order: Sort order ("ascending" or "descending")
+            include_fields: List of fields to include in results
+            
+        Returns:
+            List[Dict] or Dict: List of papers or error dict
+        """
+        query = f'cat:{category}'
+        return self.search(query, max_results, sort_by, sort_order, include_fields)
+
+    def _result_to_dict(
+        self,
+        result: Any,
+        include_fields: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Convert arxiv.Result to dictionary with selected fields."""
+        # Default fields to include
+        if include_fields is None:
+            include_fields = [
+                "title", "authors", "summary", "comment", "journal_ref",
+                "doi", "primary_category", "categories", "links"
+            ]
+        
+        # Build paper dict with selected fields
+        paper = {}
+        
+        # Always include these basic fields
+        paper["arxiv_id"] = result.entry_id.split("/")[-1]
+        paper["updated"] = result.updated.isoformat() if result.updated else None
+        paper["published"] = result.published.isoformat() if result.published else None
+        
+        # Add requested fields
+        if "title" in include_fields:
+            paper["title"] = result.title
+        if "authors" in include_fields:
+            paper["authors"] = [str(author) for author in result.authors]
+        if "summary" in include_fields:
+            paper["summary"] = result.summary
+        if "comment" in include_fields:
+            paper["comment"] = result.comment
+        if "journal_ref" in include_fields:
+            paper["journal_ref"] = result.journal_ref
+        if "doi" in include_fields:
+            paper["doi"] = result.doi
+        if "primary_category" in include_fields:
+            paper["primary_category"] = result.primary_category
+        if "categories" in include_fields:
+            paper["categories"] = result.categories
+        if "links" in include_fields:
+            paper["pdf_url"] = result.pdf_url
+            paper["abstract_url"] = f"https://arxiv.org/abs/{paper['arxiv_id']}"
+        
+        return paper
+
+# Create instance for direct function access
+_arxiv_tools = ArxivTools()
+search_arxiv = _arxiv_tools.search
+get_arxiv_paper = _arxiv_tools.get_paper
+get_papers_by_author = _arxiv_tools.get_papers_by_author
+get_papers_by_category = _arxiv_tools.get_papers_by_category
+
+if __name__ == "__main__":
+    # Example usage
+    print("\n==================================================")
+    print("ArxivTools Demonstration")
+    print("==================================================\n")
+    
+    # 1. Search for papers
+    print("1. Searching for Papers")
+    print("------------------------------")
+    query = "quantum computing"
+    papers = search_arxiv(query, max_results=3)
+    print(f"Papers about {query}:")
+    if isinstance(papers, list):
+        print(json.dumps(papers, indent=2))
+    else:
+        print(papers)  # Show error
+    print()
+    
+    # 2. Get specific paper
+    print("2. Getting Specific Paper")
+    print("------------------------------")
+    if isinstance(papers, list) and papers:
+        paper_id = papers[0]["arxiv_id"]
+        paper = get_arxiv_paper(paper_id)
+        print(f"Paper {paper_id}:")
+        if "error" not in paper:
+            print(json.dumps(paper, indent=2))
+        else:
+            print(paper)  # Show error
+    print()
+    
+    # 3. Get papers by author
+    print("3. Getting Papers by Author")
+    print("------------------------------")
+    author = "Yoshua Bengio"
+    author_papers = get_papers_by_author(author, max_results=3)
+    print(f"Papers by {author}:")
+    if isinstance(author_papers, list):
+        print(json.dumps(author_papers, indent=2))
+    else:
+        print(author_papers)  # Show error
+    print()
+    
+    # 4. Get papers by category
+    print("4. Getting Papers by Category")
+    print("------------------------------")
+    category = "cs.AI"
+    category_papers = get_papers_by_category(category, max_results=3)
+    print(f"Papers in category {category}:")
+    if isinstance(category_papers, list):
+        print(json.dumps(category_papers, indent=2))
+    else:
+        print(category_papers)  # Show error
+    
+    print("\n==================================================")
+    print("Demonstration Complete")
+    print("==================================================")

agents/praisonaiagents/tools/calculator_tools.py

@@ -0,0 +1,278 @@
+"""Tools for performing calculations.
+
+Usage:
+from praisonaiagents.tools import calculator_tools
+result = calculator_tools.evaluate("2 + 2 * 3")
+
+or
+from praisonaiagents.tools import evaluate, solve_equation, convert_units
+result = evaluate("2 + 2 * 3")
+"""
+
+import logging
+from typing import List, Dict, Optional, Any
+from importlib import util
+import math
+
+class CalculatorTools:
+    """Tools for performing calculations."""
+    
+    def __init__(self):
+        """Initialize CalculatorTools."""
+        self._check_dependencies()
+        
+    def _check_dependencies(self):
+        """Check if required packages are installed."""
+        missing = []
+        for package in ['sympy', 'pint']:
+            if util.find_spec(package) is None:
+                missing.append(package)
+        
+        if missing:
+            raise ImportError(
+                f"Required packages not available. Please install: {', '.join(missing)}\n"
+                f"Run: pip install {' '.join(missing)}"
+            )
+
+    def evaluate(
+        self,
+        expression: str,
+        variables: Optional[Dict[str, float]] = None,
+        precision: int = 10
+    ) -> Dict[str, Any]:
+        """Evaluate a mathematical expression."""
+        try:
+            if util.find_spec('sympy') is None:
+                error_msg = "sympy package is not available. Please install it using: pip install sympy"
+                logging.error(error_msg)
+                return {"error": error_msg}
+
+            # Import sympy only when needed
+            import sympy
+
+            # Replace common mathematical functions
+            expression = expression.lower()
+            replacements = {
+                'sin(': 'math.sin(',
+                'cos(': 'math.cos(',
+                'tan(': 'math.tan(',
+                'sqrt(': 'math.sqrt(',
+                'log(': 'math.log(',
+                'exp(': 'math.exp(',
+                'pi': str(math.pi),
+                'e': str(math.e)
+            }
+            for old, new in replacements.items():
+                expression = expression.replace(old, new)
+            
+            # Create safe namespace
+            safe_dict = {
+                'math': math,
+                '__builtins__': None
+            }
+            if variables:
+                safe_dict.update(variables)
+            
+            # Evaluate expression
+            result = eval(expression, safe_dict)
+            
+            # Round to specified precision
+            if isinstance(result, (int, float)):
+                return {"result": round(float(result), precision)}
+            return {"error": "Invalid expression"}
+        except Exception as e:
+            error_msg = f"Error evaluating expression: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def solve_equation(
+        self,
+        equation: str,
+        variable: str = 'x'
+    ) -> Dict[str, Any]:
+        """Solve a mathematical equation."""
+        try:
+            if util.find_spec('sympy') is None:
+                error_msg = "sympy package is not available. Please install it using: pip install sympy"
+                logging.error(error_msg)
+                return {"error": error_msg}
+
+            # Import sympy only when needed
+            import sympy
+
+            # Parse equation
+            if '=' in equation:
+                left, right = equation.split('=')
+                equation = f"({left}) - ({right})"
+            
+            # Convert to SymPy expression
+            x = sympy.Symbol(variable)
+            expr = sympy.sympify(equation)
+            
+            # Solve equation
+            solutions = sympy.solve(expr, x)
+            
+            # Convert complex solutions to real if possible
+            real_solutions = []
+            for sol in solutions:
+                if sol.is_real:
+                    real_solutions.append(float(sol))
+            
+            return {"solutions": real_solutions} if real_solutions else {"error": "No real solutions found"}
+        except Exception as e:
+            error_msg = f"Error solving equation: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def convert_units(
+        self,
+        value: float,
+        from_unit: str,
+        to_unit: str
+    ) -> Dict[str, Any]:
+        """Convert between different units."""
+        try:
+            if util.find_spec('pint') is None:
+                error_msg = "pint package is not available. Please install it using: pip install pint"
+                logging.error(error_msg)
+                return {"error": error_msg}
+
+            # Import pint only when needed
+            import pint
+
+            # Create quantity with source unit
+            ureg = pint.UnitRegistry()
+            quantity = value * ureg(from_unit)
+            
+            # Convert to target unit
+            result = quantity.to(to_unit)
+            
+            return {"result": float(result.magnitude)}
+        except Exception as e:
+            error_msg = f"Error converting units: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def calculate_statistics(
+        self,
+        numbers: List[float]
+    ) -> Dict[str, Any]:
+        """Calculate basic statistics for a list of numbers."""
+        try:
+            if not numbers:
+                return {"error": "No numbers provided"}
+            
+            n = len(numbers)
+            mean = sum(numbers) / n
+            
+            # Calculate variance and std dev
+            squared_diff_sum = sum((x - mean) ** 2 for x in numbers)
+            variance = squared_diff_sum / (n - 1) if n > 1 else 0
+            std_dev = math.sqrt(variance)
+            
+            # Calculate median
+            sorted_nums = sorted(numbers)
+            if n % 2 == 0:
+                median = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
+            else:
+                median = sorted_nums[n//2]
+            
+            return {
+                "mean": mean,
+                "median": median,
+                "std_dev": std_dev,
+                "variance": variance,
+                "min": min(numbers),
+                "max": max(numbers),
+                "range": max(numbers) - min(numbers),
+                "count": n
+            }
+        except Exception as e:
+            error_msg = f"Error calculating statistics: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def calculate_financial(
+        self,
+        principal: float,
+        rate: float,
+        time: float,
+        frequency: str = 'yearly'
+    ) -> Dict[str, Any]:
+        """Calculate financial metrics like compound interest."""
+        try:
+            # Convert rate to decimal
+            rate = rate / 100
+            
+            # Get compounding frequency
+            freq_map = {
+                'yearly': 1,
+                'semi-annual': 2,
+                'quarterly': 4,
+                'monthly': 12,
+                'daily': 365
+            }
+            n = freq_map.get(frequency.lower(), 1)
+            
+            # Calculate compound interest
+            amount = principal * (1 + rate/n)**(n*time)
+            interest = amount - principal
+            
+            # Calculate simple interest
+            simple_interest = principal * rate * time
+            
+            return {
+                "final_amount": amount,
+                "compound_interest": interest,
+                "simple_interest": simple_interest,
+                "difference": interest - simple_interest
+            }
+        except Exception as e:
+            error_msg = f"Error calculating financial metrics: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+# Create instance for direct function access
+_calculator_tools = CalculatorTools()
+evaluate = _calculator_tools.evaluate
+solve_equation = _calculator_tools.solve_equation
+convert_units = _calculator_tools.convert_units
+calculate_statistics = _calculator_tools.calculate_statistics
+calculate_financial = _calculator_tools.calculate_financial
+
+if __name__ == "__main__":
+    print("\n==================================================")
+    print("CalculatorTools Demonstration")
+    print("==================================================\n")
+
+    print("1. Basic Arithmetic")
+    print("------------------------------")
+    print("2 + 2 =", evaluate("2 + 2")["result"])
+    print("5 * 6 =", evaluate("5 * 6")["result"])
+    print("10 / 3 =", evaluate("10 / 3")["result"])
+    print()
+
+    print("2. Complex Expressions")
+    print("------------------------------")
+    print("(2 + 3) * 4 =", evaluate("(2 + 3) * 4")["result"])
+    print("2^3 + 4 =", evaluate("2^3 + 4")["result"])
+    print("sqrt(16) + 2 =", evaluate("sqrt(16) + 2")["result"])
+    print()
+
+    print("3. Solving Equations")
+    print("------------------------------")
+    result = solve_equation("x^2 - 5*x + 6 = 0")
+    print("x^2 - 5*x + 6 = 0")
+    print("Solutions:", result["solutions"])
+    print()
+
+    print("4. Unit Conversions")
+    print("------------------------------")
+    print("100 meters to kilometers:", convert_units(100, "meters", "kilometers")["result"])
+    print("1 hour to minutes:", convert_units(1, "hours", "minutes")["result"])
+    print("32 fahrenheit to celsius:", convert_units(32, "fahrenheit", "celsius")["result"])
+    print()
+
+    print("==================================================")
+    print("Demonstration Complete")
+    print("==================================================")

agents/praisonaiagents/tools/csv_tools.py

@@ -0,0 +1,266 @@
+"""Tools for working with CSV files.
+
+Usage:
+from praisonaiagents.tools import csv_tools
+df = csv_tools.read_csv("data.csv")
+
+or
+from praisonaiagents.tools import read_csv, write_csv, merge_csv
+df = read_csv("data.csv")
+"""
+
+import logging
+from typing import List, Dict, Union, Optional, Any, TYPE_CHECKING
+from importlib import util
+import json
+import csv
+from pathlib import Path
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+class CSVTools:
+    """Tools for working with CSV files."""
+    
+    def __init__(self):
+        """Initialize CSVTools."""
+        pass
+
+    def _get_pandas(self) -> Optional['pd']:
+        """Get pandas module, installing if needed"""
+        if util.find_spec('pandas') is None:
+            error_msg = "pandas package is not available. Please install it using: pip install pandas"
+            logging.error(error_msg)
+            return None
+        import pandas as pd
+        return pd
+
+    def read_csv(
+        self,
+        filepath: str,
+        encoding: str = 'utf-8',
+        delimiter: str = ',',
+        header: Union[int, List[int], None] = 0,
+        usecols: Optional[List[str]] = None,
+        dtype: Optional[Dict[str, str]] = None,
+        parse_dates: Optional[List[str]] = None,
+        na_values: Optional[List[str]] = None,
+        nrows: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """Read a CSV file with advanced options.
+        
+        Args:
+            filepath: Path to CSV file
+            encoding: File encoding
+            delimiter: Column delimiter
+            header: Row number(s) to use as column names
+            usecols: Columns to read
+            dtype: Dict of column dtypes
+            parse_dates: List of columns to parse as dates
+            na_values: Additional strings to recognize as NA/NaN
+            nrows: Number of rows to read
+            
+        Returns:
+            List of row dicts
+        """
+        try:
+            pd = self._get_pandas()
+            if pd is None:
+                return {"error": "pandas package not available"}
+
+            df = pd.read_csv(
+                filepath,
+                encoding=encoding,
+                delimiter=delimiter,
+                header=header,
+                usecols=usecols,
+                dtype=dtype,
+                parse_dates=parse_dates,
+                na_values=na_values,
+                nrows=nrows
+            )
+            return df.to_dict('records')
+            
+        except Exception as e:
+            error_msg = f"Error reading CSV file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def write_csv(
+        self,
+        filepath: str,
+        data: List[Dict[str, Any]],
+        encoding: str = 'utf-8',
+        delimiter: str = ',',
+        index: bool = False,
+        header: bool = True,
+        float_format: Optional[str] = None,
+        date_format: Optional[str] = None,
+        mode: str = 'w'
+    ) -> bool:
+        """Write data to a CSV file.
+        
+        Args:
+            filepath: Path to CSV file
+            data: List of row dicts to write
+            encoding: File encoding
+            delimiter: Column delimiter
+            index: Whether to write row indices
+            header: Whether to write column headers
+            float_format: Format string for float values
+            date_format: Format string for date values
+            mode: Write mode ('w' for write, 'a' for append)
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            pd = self._get_pandas()
+            if pd is None:
+                return False
+
+            df = pd.DataFrame(data)
+            df.to_csv(
+                filepath,
+                encoding=encoding,
+                sep=delimiter,
+                index=index,
+                header=header,
+                float_format=float_format,
+                date_format=date_format,
+                mode=mode
+            )
+            return True
+            
+        except Exception as e:
+            error_msg = f"Error writing CSV file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+    def merge_csv(
+        self,
+        files: List[str],
+        output_file: str,
+        how: str = 'inner',
+        on: Optional[Union[str, List[str]]] = None,
+        suffixes: Optional[tuple] = None
+    ) -> bool:
+        """Merge multiple CSV files.
+        
+        Args:
+            files: List of CSV files to merge
+            output_file: Output file path
+            how: Merge method ('inner', 'outer', 'left', 'right')
+            on: Column(s) to merge on
+            suffixes: Suffixes for overlapping columns
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            if len(files) < 2:
+                error_msg = "At least two files are required for merging"
+                logging.error(error_msg)
+                return False
+            
+            pd = self._get_pandas()
+            if pd is None:
+                return False
+
+            # Read first file
+            result = pd.read_csv(files[0])
+            
+            # Merge with remaining files
+            for file in files[1:]:
+                df = pd.read_csv(file)
+                result = pd.merge(
+                    result,
+                    df,
+                    how=how,
+                    on=on,
+                    suffixes=suffixes or ('_1', '_2')
+                )
+            
+            # Write merged result
+            result.to_csv(output_file, index=False)
+            return True
+            
+        except Exception as e:
+            error_msg = f"Error merging CSV files: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+# Create instance for direct function access
+_csv_tools = CSVTools()
+read_csv = _csv_tools.read_csv
+write_csv = _csv_tools.write_csv
+merge_csv = _csv_tools.merge_csv
+
+if __name__ == "__main__":
+    print("\n==================================================")
+    print("CSVTools Demonstration")
+    print("==================================================\n")
+    
+    # Create a temporary file for testing
+    import tempfile
+    import os
+    
+    with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp:
+        temp_file = temp.name
+        
+        print("1. Writing CSV File")
+        print("------------------------------")
+        data = [
+            {"name": "Alice", "age": 25, "city": "New York"},
+            {"name": "Bob", "age": 30, "city": "San Francisco"},
+            {"name": "Charlie", "age": 35, "city": "Chicago"}
+        ]
+        result = write_csv(temp_file, data)
+        print(f"Data written successfully: {result}")
+        print()
+        
+        print("2. Reading CSV File")
+        print("------------------------------")
+        read_data = read_csv(temp_file)
+        print("Contents of CSV file:")
+        for row in read_data:
+            print(row)
+        print()
+        
+        print("3. Merging CSV Files")
+        print("------------------------------")
+        # Create a second file for merging
+        with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp2:
+            temp_file2 = temp2.name
+            data2 = [
+                {"name": "Alice", "salary": 75000},
+                {"name": "Bob", "salary": 85000},
+                {"name": "Charlie", "salary": 95000}
+            ]
+            write_csv(temp_file2, data2)
+            
+            # Merge files
+            with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp3:
+                temp_file3 = temp3.name
+                result = merge_csv(
+                    [temp_file, temp_file2],
+                    temp_file3,
+                    how='inner',
+                    on='name'
+                )
+                print(f"Files merged successfully: {result}")
+                if result:
+                    merged_data = read_csv(temp_file3)
+                    print("\nMerged contents:")
+                    for row in merged_data:
+                        print(row)
+                print()
+        
+        # Clean up temporary files
+        os.unlink(temp_file)
+        os.unlink(temp_file2)
+        os.unlink(temp_file3)
+    
+    print("==================================================")
+    print("Demonstration Complete")
+    print("==================================================\n")

agents/praisonaiagents/tools/duckdb_tools.py

@@ -0,0 +1,268 @@
+"""Tools for working with DuckDB databases.
+
+Usage:
+from praisonaiagents.tools import duckdb_tools
+df = duckdb_tools.query("SELECT * FROM my_table")
+
+or
+from praisonaiagents.tools import query_db, create_table, load_data
+df = query_db("SELECT * FROM my_table")
+"""
+
+import logging
+from typing import List, Dict, Any, Optional, Union, TYPE_CHECKING
+from importlib import util
+import json
+
+if TYPE_CHECKING:
+    import duckdb
+    import pandas as pd
+
+class DuckDBTools:
+    """Tools for working with DuckDB databases."""
+    
+    def __init__(self, database: str = ':memory:'):
+        """Initialize DuckDBTools.
+        
+        Args:
+            database: Path to database file or ':memory:' for in-memory database
+        """
+        self.database = database
+        self._conn = None
+
+    def _get_duckdb(self) -> Optional['duckdb']:
+        """Get duckdb module, installing if needed"""
+        if util.find_spec('duckdb') is None:
+            error_msg = "duckdb package is not available. Please install it using: pip install duckdb"
+            logging.error(error_msg)
+            return None
+        import duckdb
+        return duckdb
+
+    def _get_pandas(self) -> Optional['pd']:
+        """Get pandas module, installing if needed"""
+        if util.find_spec('pandas') is None:
+            error_msg = "pandas package is not available. Please install it using: pip install pandas"
+            logging.error(error_msg)
+            return None
+        import pandas as pd
+        return pd
+
+    def _get_connection(self) -> Optional['duckdb.DuckDBPyConnection']:
+        """Get or create database connection"""
+        if self._conn is None:
+            duckdb = self._get_duckdb()
+            if duckdb is None:
+                return None
+            try:
+                self._conn = duckdb.connect(self.database)
+            except Exception as e:
+                error_msg = f"Error connecting to database {self.database}: {str(e)}"
+                logging.error(error_msg)
+                return None
+        return self._conn
+
+    def execute_query(
+        self,
+        query: str,
+        params: Optional[Union[tuple, dict]] = None,
+        return_df: bool = True
+    ) -> Union[List[Dict[str, Any]], Dict[str, str]]:
+        """Execute a SQL query.
+        
+        Args:
+            query: SQL query to execute
+            params: Query parameters
+            return_df: If True, return results as DataFrame records
+            
+        Returns:
+            Query results as list of dicts, or error dict
+        """
+        try:
+            conn = self._get_connection()
+            if conn is None:
+                return {"error": "Could not connect to database"}
+
+            if params:
+                result = conn.execute(query, params)
+            else:
+                result = conn.execute(query)
+
+            if return_df:
+                pd = self._get_pandas()
+                if pd is None:
+                    return {"error": "pandas package not available"}
+                df = result.df()
+                return df.to_dict('records')
+            else:
+                return [dict(row) for row in result.fetchall()]
+
+        except Exception as e:
+            error_msg = f"Error executing query: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def load_csv(
+        self,
+        table_name: str,
+        filepath: str,
+        schema: Optional[Dict[str, str]] = None,
+        if_exists: str = 'replace'
+    ) -> bool:
+        """Load a CSV file into a table.
+        
+        Args:
+            table_name: Name of table to create
+            filepath: Path to CSV file
+            schema: Optional column definitions
+            if_exists: What to do if table exists ('fail', 'replace', 'append')
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            conn = self._get_connection()
+            if conn is None:
+                return False
+
+            # Check if table exists
+            exists = conn.execute(f"""
+                SELECT name FROM sqlite_master 
+                WHERE type='table' AND name='{table_name}'
+            """).fetchone() is not None
+
+            if exists:
+                if if_exists == 'fail':
+                    raise ValueError(f"Table {table_name} already exists")
+                elif if_exists == 'replace':
+                    conn.execute(f"DROP TABLE IF EXISTS {table_name}")
+                elif if_exists != 'append':
+                    raise ValueError("if_exists must be 'fail', 'replace', or 'append'")
+
+            # Create table if needed
+            if not exists or if_exists == 'replace':
+                if schema:
+                    # Create table with schema
+                    columns = ', '.join(f"{k} {v}" for k, v in schema.items())
+                    conn.execute(f"CREATE TABLE {table_name} ({columns})")
+                else:
+                    # Infer schema from CSV
+                    conn.execute(f"""
+                        CREATE TABLE {table_name} AS 
+                        SELECT * FROM read_csv_auto('{filepath}')
+                        WHERE 1=0
+                    """)
+
+            # Load data
+            conn.execute(f"""
+                INSERT INTO {table_name}
+                SELECT * FROM read_csv_auto('{filepath}')
+            """)
+
+            return True
+
+        except Exception as e:
+            error_msg = f"Error loading CSV file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+    def export_csv(
+        self,
+        query: str,
+        filepath: str,
+        params: Optional[Union[tuple, dict]] = None
+    ) -> bool:
+        """Export query results to CSV.
+        
+        Args:
+            query: SQL query to execute
+            filepath: Output file path
+            params: Optional query parameters
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            # Execute query and get results as DataFrame
+            results = self.execute_query(query, params)
+            if isinstance(results, dict) and 'error' in results:
+                return False
+
+            pd = self._get_pandas()
+            if pd is None:
+                return False
+
+            # Convert to DataFrame and save
+            df = pd.DataFrame(results)
+            df.to_csv(filepath, index=False)
+            return True
+
+        except Exception as e:
+            error_msg = f"Error exporting to CSV file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+    def close(self):
+        """Close database connection."""
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+# Create instance for direct function access
+_duckdb_tools = DuckDBTools()
+execute_query = _duckdb_tools.execute_query
+load_csv = _duckdb_tools.load_csv
+export_csv = _duckdb_tools.export_csv
+
+if __name__ == "__main__":
+    print("\n==================================================")
+    print("DuckDBTools Demonstration")
+    print("==================================================\n")
+    
+    # Create a temporary file for testing
+    import tempfile
+    import os
+    
+    with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp:
+        temp_file = temp.name
+        
+        # Create sample data
+        with open(temp_file, 'w') as f:
+            f.write("name,age,city\n")
+            f.write("Alice,25,New York\n")
+            f.write("Bob,30,San Francisco\n")
+            f.write("Charlie,35,Chicago\n")
+        
+        print("1. Loading CSV File")
+        print("------------------------------")
+        result = load_csv('users', temp_file)
+        print(f"CSV loaded successfully: {result}")
+        print()
+        
+        print("2. Executing Query")
+        print("------------------------------")
+        query = "SELECT * FROM users WHERE age > 25"
+        results = execute_query(query)
+        print("Query results:")
+        for row in results:
+            print(row)
+        print()
+        
+        print("3. Exporting Query Results")
+        print("------------------------------")
+        with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp2:
+            temp_file2 = temp2.name
+            result = export_csv(query, temp_file2)
+            print(f"Results exported successfully: {result}")
+            if result:
+                print("\nExported file contents:")
+                with open(temp_file2) as f:
+                    print(f.read())
+        
+        # Clean up temporary files
+        os.unlink(temp_file)
+        os.unlink(temp_file2)
+    
+    print("==================================================")
+    print("Demonstration Complete")
+    print("==================================================\n")

agents/praisonaiagents/tools/duckduckgo_tools.py

@@ -0,0 +1,52 @@
+"""DuckDuckGo search functionality.
+
+Usage:
+from praisonaiagents.tools import internet_search
+results = internet_search("AI news")
+
+or 
+from praisonaiagents.tools import duckduckgo
+results = duckduckgo("AI news")
+"""
+
+from typing import List, Dict
+import logging
+from importlib import util
+
+def internet_search(query: str) -> List[Dict]:
+    """Perform an internet search using DuckDuckGo."""
+    # Check if duckduckgo_search is installed
+    if util.find_spec("duckduckgo_search") is None:
+        error_msg = "DuckDuckGo search is not available. Please install duckduckgo_search package using: pip install duckduckgo_search"
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+
+    try:
+        # Import only when needed
+        from duckduckgo_search import DDGS
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=5):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+
+    except Exception as e:
+        error_msg = f"Error during DuckDuckGo search: {e}"
+        logging.error(error_msg)
+        return [{"error": error_msg}]
+
+def duckduckgo(query: str) -> List[Dict]:
+    """Alias for internet_search function."""
+    return internet_search(query)
+
+if __name__ == "__main__":
+    # Example usage
+    results = internet_search("Python programming")
+    for result in results:
+        print(f"\nTitle: {result.get('title')}")
+        print(f"URL: {result.get('url')}")
+        print(f"Snippet: {result.get('snippet')}")

agents/praisonaiagents/tools/excel_tools.py

@@ -0,0 +1,310 @@
+"""Tools for working with Excel files.
+
+Usage:
+from praisonaiagents.tools import excel_tools
+df = excel_tools.read_excel("data.xlsx")
+
+or
+from praisonaiagents.tools import read_excel, write_excel, merge_excel
+df = read_excel("data.xlsx")
+"""
+
+import logging
+from typing import List, Dict, Union, Optional, Any, TYPE_CHECKING, Tuple
+from importlib import util
+import json
+from pathlib import Path
+import tempfile
+import os
+
+if TYPE_CHECKING:
+    import pandas as pd
+    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+    from openpyxl.chart import BarChart, LineChart, PieChart, Reference
+    from openpyxl.chart.label import DataLabelList
+
+class ExcelTools:
+    """Tools for working with Excel files."""
+    
+    def __init__(self):
+        """Initialize ExcelTools."""
+        pass
+
+    def _get_pandas(self) -> Optional['pd']:
+        """Get pandas module, installing if needed"""
+        if util.find_spec('pandas') is None:
+            error_msg = "pandas package is not available. Please install it using: pip install pandas"
+            logging.error(error_msg)
+            return None
+        if util.find_spec('openpyxl') is None:
+            error_msg = "openpyxl package is not available. Please install it using: pip install openpyxl"
+            logging.error(error_msg)
+            return None
+        import pandas as pd
+        return pd
+
+    def read_excel(
+        self,
+        filepath: str,
+        sheet_name: Optional[Union[str, int, List[Union[str, int]]]] = 0,
+        header: Optional[int] = 0,
+        usecols: Optional[List[str]] = None,
+        skiprows: Optional[Union[int, List[int]]] = None,
+        na_values: Optional[List[str]] = None,
+        dtype: Optional[Dict[str, str]] = None
+    ) -> Union[Dict[str, List[Dict[str, Any]]], List[Dict[str, Any]]]:
+        """Read an Excel file with advanced options.
+        
+        Args:
+            filepath: Path to Excel file
+            sheet_name: Sheet name(s) or index(es)
+            header: Row number(s) to use as column names
+            usecols: Columns to read
+            skiprows: Line numbers to skip
+            na_values: Additional strings to recognize as NA/NaN
+            dtype: Dict of column dtypes
+            
+        Returns:
+            Dict of sheet names to data if multiple sheets, else list of row dicts
+        """
+        try:
+            pd = self._get_pandas()
+            if pd is None:
+                return {"error": "Required packages not available"}
+
+            # Read Excel file
+            df = pd.read_excel(
+                filepath,
+                sheet_name=sheet_name,
+                header=header,
+                usecols=usecols,
+                skiprows=skiprows,
+                na_values=na_values,
+                dtype=dtype,
+                engine='openpyxl'
+            )
+            
+            # Convert to dict format
+            if isinstance(df, dict):
+                return {
+                    name: df[name].to_dict('records')
+                    for name in df.keys()
+                }
+            else:
+                return df.to_dict('records')
+                
+        except Exception as e:
+            error_msg = f"Error reading Excel file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def write_excel(
+        self,
+        filepath: str,
+        data: Union[Dict[str, List[Dict[str, Any]]], List[Dict[str, Any]]],
+        sheet_name: Optional[str] = None,
+        index: bool = False,
+        header: bool = True,
+        mode: str = 'w'
+    ) -> bool:
+        """Write data to an Excel file.
+        
+        Args:
+            filepath: Path to Excel file
+            data: Data to write (dict of sheet names to data or list of row dicts)
+            sheet_name: Sheet name if data is a list
+            index: Whether to write row indices
+            header: Whether to write column headers
+            mode: Write mode ('w' for write, 'a' for append)
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            pd = self._get_pandas()
+            if pd is None:
+                return False
+
+            # Convert data to DataFrame(s)
+            if isinstance(data, dict):
+                if mode == 'a' and os.path.exists(filepath):
+                    book = pd.ExcelFile(filepath)
+                    with pd.ExcelWriter(filepath, engine='openpyxl') as writer:
+                        # Copy existing sheets
+                        for sheet in book.sheet_names:
+                            pd.read_excel(filepath, sheet_name=sheet).to_excel(
+                                writer, sheet_name=sheet, index=index, header=header
+                            )
+                        # Add new sheets
+                        for name, sheet_data in data.items():
+                            df = pd.DataFrame(sheet_data)
+                            df.to_excel(
+                                writer, sheet_name=name, index=index, header=header
+                            )
+                else:
+                    with pd.ExcelWriter(filepath, engine='openpyxl') as writer:
+                        for name, sheet_data in data.items():
+                            df = pd.DataFrame(sheet_data)
+                            df.to_excel(
+                                writer, sheet_name=name, index=index, header=header
+                            )
+            else:
+                if mode == 'a' and os.path.exists(filepath):
+                    book = pd.ExcelFile(filepath)
+                    with pd.ExcelWriter(filepath, engine='openpyxl') as writer:
+                        # Copy existing sheets
+                        for sheet in book.sheet_names:
+                            pd.read_excel(filepath, sheet_name=sheet).to_excel(
+                                writer, sheet_name=sheet, index=index, header=header
+                            )
+                        # Add new sheet
+                        df = pd.DataFrame(data)
+                        df.to_excel(
+                            writer,
+                            sheet_name=sheet_name or 'Sheet1',
+                            index=index,
+                            header=header
+                        )
+                else:
+                    df = pd.DataFrame(data)
+                    df.to_excel(
+                        filepath,
+                        sheet_name=sheet_name or 'Sheet1',
+                        index=index,
+                        header=header,
+                        engine='openpyxl'
+                    )
+            
+            return True
+            
+        except Exception as e:
+            error_msg = f"Error writing Excel file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+    def merge_excel(
+        self,
+        files: List[str],
+        output_file: str,
+        how: str = 'inner',
+        on: Optional[Union[str, List[str]]] = None,
+        suffixes: Optional[Tuple[str, str]] = None
+    ) -> bool:
+        """Merge multiple Excel files.
+        
+        Args:
+            files: List of Excel files to merge
+            output_file: Output file path
+            how: Merge method ('inner', 'outer', 'left', 'right')
+            on: Column(s) to merge on
+            suffixes: Suffixes for overlapping columns
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            if len(files) < 2:
+                error_msg = "At least two files are required for merging"
+                logging.error(error_msg)
+                return False
+            
+            # Read first file
+            result = self.read_excel(files[0])
+            
+            # Merge with remaining files
+            for file in files[1:]:
+                df = self.read_excel(file)
+                if isinstance(df, dict):
+                    df = next(iter(df.values()))
+                
+                pd = self._get_pandas()
+                if pd is None:
+                    return False
+                
+                result = pd.merge(
+                    pd.DataFrame(result),
+                    pd.DataFrame(df),
+                    how=how,
+                    on=on,
+                    suffixes=suffixes or ('_1', '_2')
+                ).to_dict('records')
+            
+            # Write merged result
+            return self.write_excel(output_file, result)
+            
+        except Exception as e:
+            error_msg = f"Error merging Excel files: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+# Create instance for direct function access
+_excel_tools = ExcelTools()
+read_excel = _excel_tools.read_excel
+write_excel = _excel_tools.write_excel
+merge_excel = _excel_tools.merge_excel
+
+if __name__ == "__main__":
+    print("\n==================================================")
+    print("ExcelTools Demonstration")
+    print("==================================================\n")
+    
+    # Create a temporary file for testing
+    with tempfile.NamedTemporaryFile(suffix='.xlsx', delete=False) as temp:
+        temp_file = temp.name
+        
+        print("1. Writing Excel File")
+        print("------------------------------")
+        data = [
+            {"name": "Alice", "age": 25, "city": "New York"},
+            {"name": "Bob", "age": 30, "city": "San Francisco"},
+            {"name": "Charlie", "age": 35, "city": "Chicago"}
+        ]
+        result = write_excel(temp_file, data, "People")
+        print(f"Data written successfully: {result}")
+        print()
+        
+        print("2. Reading Excel File")
+        print("------------------------------")
+        read_data = read_excel(temp_file)
+        print("Contents of Excel file:")
+        for row in read_data:
+            print(row)
+        print()
+        
+        print("3. Merging Excel Files")
+        print("------------------------------")
+        # Create a second file for merging
+        with tempfile.NamedTemporaryFile(suffix='.xlsx', delete=False) as temp2:
+            temp_file2 = temp2.name
+            data2 = [
+                {"name": "Alice", "salary": 75000},
+                {"name": "Bob", "salary": 85000},
+                {"name": "Charlie", "salary": 95000}
+            ]
+            write_excel(temp_file2, data2, "Salaries")
+            
+            # Merge files
+            with tempfile.NamedTemporaryFile(suffix='.xlsx', delete=False) as temp3:
+                temp_file3 = temp3.name
+                result = merge_excel(
+                    [temp_file, temp_file2],
+                    temp_file3,
+                    how='inner',
+                    on='name'
+                )
+                print(f"Files merged successfully: {result}")
+                if result:
+                    merged_data = read_excel(temp_file3)
+                    print("\nMerged contents:")
+                    for row in merged_data:
+                        print(row)
+                print()
+        
+        # Clean up temporary files
+        os.unlink(temp_file)
+        os.unlink(temp_file2)
+        os.unlink(temp_file3)
+    
+    print("==================================================")
+    print("Demonstration Complete")
+    print("==================================================\n")