feat(ag2): add AG2 framework backend integration (#1143)

feat(ag2): add AG2 framework backend integration

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,34 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: '[BUG] '
-labels: bug
-assignees: ''
----
-
-## Environment
-- Provider (select one):
-  - [ ] Anthropic
-  - [ ] OpenAI
-  - [ ] Google Vertex AI
-  - [ ] AWS Bedrock
-  - [ ] Other: <!-- specify -->
-- PraisonAI version: <!-- if known -->
-- Operating System: <!-- e.g. macOS 14.3, Windows 11, Ubuntu 22.04 -->
-
-## Full Code
-<!-- Full code that reproduces the bug -->
-
-## Steps to Reproduce
-1. <!-- First step -->
-2. <!-- Second step -->
-3. <!-- And so on... -->
-
-## Expected Behavior
-<!-- What you expected to happen -->
-
-## Actual Behavior
-<!-- What actually happened -->
-
-## Additional Context
-<!-- Add any other context about the problem here, such as screenshots, logs, etc. --> 

.github/actions/claude-code-action/Dockerfile

@@ -0,0 +1,9 @@
+FROM node:20-alpine
+
+RUN npm install -g @anthropic-ai/claude-code
+
+WORKDIR /app
+COPY entrypoint.sh .
+RUN chmod +x entrypoint.sh
+
+ENTRYPOINT ["/app/entrypoint.sh"] 

.github/actions/claude-code-action/action.yml

@@ -1,256 +1,20 @@
 name: "Claude Code Action"
-description: "Run Claude Code in GitHub Actions workflows"
+description: "Custom Claude Code runner for PraisonAI"
 
 inputs:
   anthropic_api_key:
+    required: true
     description: "Anthropic API key"
-    required: false
   github_token:
-    description: "GitHub token for Claude to operate with"
-    required: false
-    default: ${{ github.token }}
-  trigger_phrase:
-    description: "The trigger phrase to look for in comments, issue/PR bodies, and issue titles"
-    required: false
-    default: "@claude"
-  assignee_trigger:
-    description: "The assignee username that triggers the action (e.g. @claude). Only used for issue assignment"
-    required: false
-  max_turns:
-    description: "Maximum number of conversation turns Claude can take"
-    required: false
-  timeout_minutes:
-    description: "Timeout in minutes for execution"
-    required: false
-    default: "30"
-  model:
-    description: "Model to use (provider-specific format required for Bedrock/Vertex)"
-    required: false
-  use_bedrock:
-    description: "Use Amazon Bedrock with OIDC authentication instead of direct Anthropic API"
-    required: false
-    default: "false"
-  use_vertex:
-    description: "Use Google Vertex AI with OIDC authentication instead of direct Anthropic API"
-    required: false
-    default: "false"
-  allowed_tools:
-    description: "Additional tools for Claude to use (the base GitHub tools will always be included)"
-    required: false
-    default: ""
-  disallowed_tools:
-    description: "Tools that Claude should never use"
-    required: false
-    default: ""
-  custom_instructions:
-    description: "Additional custom instructions to include in the prompt for Claude"
-    required: false
-    default: ""
-  mcp_config:
-    description: "Additional MCP configuration (JSON string) that merges with the built-in GitHub MCP servers"
-    required: false
-    default: ""
-  claude_env:
-    description: "Custom environment variables to pass to Claude Code execution (YAML format)"
-    required: false
-    default: ""
-  direct_prompt:
-    description: "Direct prompt for Claude to execute automatically without needing a trigger (for automated workflows)"
-    required: false
+    required: true
+    description: "GitHub token for repo access"
 
 runs:
-  using: "composite"
-  steps:
-    - name: Install Claude Code
-      shell: bash
-      run: npm install -g @anthropic-ai/claude-code
-
-    - name: Install GitHub MCP Server
-      shell: bash
-      run: |
-        claude mcp add-json github '{
-          "command": "docker",
-          "args": [
-            "run",
-            "-i",
-            "--rm",
-            "-e",
-            "GITHUB_PERSONAL_ACCESS_TOKEN",
-            "ghcr.io/github/github-mcp-server:sha-ff3036d"
-          ],
-          "env": {
-            "GITHUB_PERSONAL_ACCESS_TOKEN": "${{ inputs.github_token }}"
-          }
-        }'
-
-    - name: Extract GitHub Context and Create Prompt
-      shell: bash
-      id: prepare_context
-      env:
-        # Pass user-controlled inputs via environment variables to prevent script injection (GHSL-2025-093)
-        EVENT_COMMENT_BODY: ${{ github.event.comment.body }}
-        EVENT_ISSUE_TITLE: ${{ github.event.issue.title }}
-        EVENT_ISSUE_BODY: ${{ github.event.issue.body }}
-        EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
-        EVENT_PR_TITLE: ${{ github.event.pull_request.title }}
-        EVENT_PR_NUMBER: ${{ github.event.pull_request.number }}
-        EVENT_REVIEW_BODY: ${{ github.event.review.body }}
-        EVENT_ASSIGNEE_LOGIN: ${{ github.event.assignee.login }}
-        INPUT_TRIGGER_PHRASE: ${{ inputs.trigger_phrase }}
-        INPUT_ASSIGNEE_TRIGGER: ${{ inputs.assignee_trigger }}
-        INPUT_DIRECT_PROMPT: ${{ inputs.direct_prompt }}
-        EVENT_ACTION: ${{ github.event.action }}
-        EVENT_NAME: ${{ github.event_name }}
-        REPO_NAME: ${{ github.repository }}
-      run: |
-        echo "🔍 Extracting GitHub context from event: $EVENT_NAME"
-        
-        # Function to check for trigger phrase
-        check_trigger() {
-          local text="$1"
-          local trigger="$INPUT_TRIGGER_PHRASE"
-          if [[ "$text" == *"$trigger"* ]]; then
-            return 0
-          fi
-          return 1
-        }
-        
-        # Extract context based on event type
-        TRIGGER_FOUND="false"
-        USER_REQUEST=""
-        CONTEXT_INFO=""
-        
-        case "$EVENT_NAME" in
-          "issue_comment")
-            COMMENT_BODY="$EVENT_COMMENT_BODY"
-            ISSUE_TITLE="$EVENT_ISSUE_TITLE"
-            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
-            
-            if check_trigger "$COMMENT_BODY"; then
-              TRIGGER_FOUND="true"
-              USER_REQUEST="$COMMENT_BODY"
-              CONTEXT_INFO="Issue Comment on #$ISSUE_NUMBER: $ISSUE_TITLE"
-            fi
-            ;;
-            
-          "pull_request_review_comment")
-            COMMENT_BODY="$EVENT_COMMENT_BODY"
-            PR_TITLE="$EVENT_PR_TITLE"
-            PR_NUMBER="$EVENT_PR_NUMBER"
-            
-            if check_trigger "$COMMENT_BODY"; then
-              TRIGGER_FOUND="true"
-              USER_REQUEST="$COMMENT_BODY"
-              CONTEXT_INFO="PR Comment on #$PR_NUMBER: $PR_TITLE"
-            fi
-            ;;
-            
-          "pull_request_review")
-            REVIEW_BODY="$EVENT_REVIEW_BODY"
-            PR_TITLE="$EVENT_PR_TITLE"
-            PR_NUMBER="$EVENT_PR_NUMBER"
-            
-            if check_trigger "$REVIEW_BODY"; then
-              TRIGGER_FOUND="true"
-              USER_REQUEST="$REVIEW_BODY"
-              CONTEXT_INFO="PR Review on #$PR_NUMBER: $PR_TITLE"
-            fi
-            ;;
-            
-          "issues")
-            ISSUE_BODY="$EVENT_ISSUE_BODY"
-            ISSUE_TITLE="$EVENT_ISSUE_TITLE"
-            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
-            
-            if check_trigger "$ISSUE_TITLE" || check_trigger "$ISSUE_BODY"; then
-              TRIGGER_FOUND="true"
-              USER_REQUEST="$ISSUE_BODY"
-              CONTEXT_INFO="Issue #$ISSUE_NUMBER: $ISSUE_TITLE"
-            elif [[ "$EVENT_ACTION" == "assigned" && -n "$INPUT_ASSIGNEE_TRIGGER" ]]; then
-              ASSIGNEE="$EVENT_ASSIGNEE_LOGIN"
-              if [[ "$ASSIGNEE" == "$INPUT_ASSIGNEE_TRIGGER" ]]; then
-                TRIGGER_FOUND="true"
-                USER_REQUEST="$ISSUE_BODY"
-                CONTEXT_INFO="Issue #$ISSUE_NUMBER assigned to $ASSIGNEE: $ISSUE_TITLE"
-              fi
-            fi
-            ;;
-        esac
-        
-        # Check for direct prompt override
-        if [[ -n "$INPUT_DIRECT_PROMPT" ]]; then
-          TRIGGER_FOUND="true"
-          USER_REQUEST="$INPUT_DIRECT_PROMPT"
-          CONTEXT_INFO="Automated GitHub workflow"
-        fi
-        
-        if [[ "$TRIGGER_FOUND" != "true" ]]; then
-          echo "❌ No trigger phrase found or direct prompt provided. Exiting gracefully."
-          echo "SKIP_EXECUTION=true" >> $GITHUB_ENV
-          exit 0
-        fi
-        
-        echo "✅ Trigger found! Context: $CONTEXT_INFO"
-        
-        # Create comprehensive prompt
-        mkdir -p /tmp/claude-action
-        cat > /tmp/claude-action/github-context-prompt.txt << EOF
-        You are Claude Code, an AI assistant helping with GitHub workflows and code.
-        
-        Repository: $REPO_NAME
-        Context: $CONTEXT_INFO
-        Event: $EVENT_NAME
-        
-        User Request:
-        $USER_REQUEST
-        
-        Please analyze the request and provide helpful assistance. You have access to repository tools and can help with:
-        - Code analysis and implementation
-        - GitHub workflows and automation
-        - Pull request reviews and feedback
-        - Issue resolution and bug fixes
-        - Documentation updates
-        - Testing and deployment
-        
-        Respond naturally and helpfully to the user's request using the available tools.
-        EOF
-        
-        echo "PROMPT_FILE=/tmp/claude-action/github-context-prompt.txt" >> $GITHUB_ENV
-        echo "SKIP_EXECUTION=false" >> $GITHUB_ENV
-
-    - name: Run Claude Code
-      if: env.SKIP_EXECUTION != 'true'
-      shell: bash
-      run: |
-        echo "🚀 Running Claude Code with GitHub context..."
-        
-        # Build command arguments
-        CMD_ARGS=("-p" "--verbose" "--output-format" "stream-json")
-        
-        # Add max turns if specified
-        if [[ -n "${{ inputs.max_turns }}" ]]; then
-          CMD_ARGS+=("--max-turns" "${{ inputs.max_turns }}")
-        fi
-        
-        # Add allowed tools (include GitHub tools by default)
-        TOOLS="mcp__github__get_issue,mcp__github__get_issue_comments,mcp__github__update_issue,mcp__github__search_issues,mcp__github__list_issues,mcp__github__create_comment,Read,Write,Edit,Bash"
-        if [[ -n "${{ inputs.allowed_tools }}" ]]; then
-          TOOLS="$TOOLS,${{ inputs.allowed_tools }}"
-        fi
-        CMD_ARGS+=("--allowedTools" "$TOOLS")
-        
-        # Add disallowed tools
-        if [[ -n "${{ inputs.disallowed_tools }}" ]]; then
-          CMD_ARGS+=("--disallowedTools" "${{ inputs.disallowed_tools }}")
-        fi
-        
-        echo "📝 Executing Claude Code with prompt from file..."
-        
-        # Execute Claude Code with timeout, using stdin for the prompt
-        TIMEOUT_SECONDS=$((${{ inputs.timeout_minutes }} * 60))
-        timeout $TIMEOUT_SECONDS claude "${CMD_ARGS[@]}" < "${{ env.PROMPT_FILE }}"
-        
-        echo "✅ Claude Code execution completed"
-      env:
-        ANTHROPIC_API_KEY: ${{ inputs.anthropic_api_key }}
-        GITHUB_TOKEN: ${{ inputs.github_token }} 
+  using: "docker"
+  image: "ghcr.io/mervinpraison/praisonai-claudecode:latest"
+  env:
+    ANTHROPIC_API_KEY: ${{ inputs.anthropic_api_key }}
+    GITHUB_TOKEN: ${{ inputs.github_token }}
+  args:
+    - "--anthropic-api-key=${{ inputs.anthropic_api_key }}"
+    - "--github-token=${{ inputs.github_token }}" 

.github/actions/claude-code-action/entrypoint.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+set -e
+
+echo "Running Claude Code in CI mode..."
+
+# Extract GitHub context and create a smart prompt
+PROMPT="Analyse the GitHub issue or PR context and generate a smart response based on the repository context."
+
+# Set environment variables from arguments
+export ANTHROPIC_API_KEY="${1#--anthropic-api-key=}"
+export GITHUB_TOKEN="${2#--github-token=}"
+
+# Verify environment variables
+if [ -z "$ANTHROPIC_API_KEY" ] || [ -z "$GITHUB_TOKEN" ]; then
+    echo "Error: Required environment variables are not set"
+    exit 1
+fi
+
+# Run Claude with the prompt
+claude -p "$PROMPT" 

.github/actions/claude-code/action.yml

@@ -0,0 +1,117 @@
+name: "Claude Code Action"
+description: "Run Claude Code in GitHub Actions workflows"
+
+inputs:
+  github_token:
+    description: "GitHub token with repo and issues permissions"
+    required: true
+  anthropic_api_key:
+    description: "Anthropic API key"
+    required: true
+  prompt:
+    description: "The prompt to send to Claude Code"
+    required: false
+    default: ""
+  prompt_file:
+    description: "Path to a file containing the prompt to send to Claude Code"
+    required: false
+    default: ""
+  allowed_tools:
+    description: "Comma-separated list of allowed tools for Claude Code to use"
+    required: false
+    default: ""
+  output_file:
+    description: "File to save Claude Code output to (optional)"
+    required: false
+    default: ""
+  timeout_minutes:
+    description: "Timeout in minutes for Claude Code execution"
+    required: false
+    default: "10"
+  install_github_mcp:
+    description: "Whether to install the GitHub MCP server"
+    required: false
+    default: "false"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install Claude Code
+      shell: bash
+      run: npm install -g @anthropic-ai/claude-code
+
+    - name: Install GitHub MCP Server
+      if: inputs.install_github_mcp == 'true'
+      shell: bash
+      run: |
+        claude mcp add-json github '{
+          "command": "docker",
+          "args": [
+            "run",
+            "-i",
+            "--rm",
+            "-e",
+            "GITHUB_PERSONAL_ACCESS_TOKEN",
+            "ghcr.io/github/github-mcp-server:sha-ff3036d"
+          ],
+          "env": {
+            "GITHUB_PERSONAL_ACCESS_TOKEN": "${{ inputs.GITHUB_TOKEN }}"
+          }
+        }'
+
+    - name: Prepare Prompt File
+      shell: bash
+      id: prepare_prompt
+      run: |
+        if [ -z "${{ inputs.prompt }}" ] && [ -z "${{ inputs.prompt_file }}" ]; then
+          echo "::error::Neither 'prompt' nor 'prompt_file' was provided. At least one is required."
+          exit 1
+        fi
+
+        if [ ! -z "${{ inputs.prompt_file }}" ]; then
+          if [ ! -f "${{ inputs.prompt_file }}" ]; then
+            echo "::error::Prompt file '${{ inputs.prompt_file }}' does not exist."
+            exit 1
+          fi
+          PROMPT_PATH="${{ inputs.prompt_file }}"
+        else
+          mkdir -p /tmp/claude-action
+          PROMPT_PATH="/tmp/claude-action/prompt.txt"
+          echo "${{ inputs.prompt }}" > "$PROMPT_PATH"
+        fi
+
+        if [ ! -s "$PROMPT_PATH" ]; then
+          echo "::error::Prompt is empty. Please provide a non-empty prompt."
+          exit 1
+        fi
+
+        echo "PROMPT_PATH=$PROMPT_PATH" >> $GITHUB_ENV
+
+    - name: Run Claude Code
+      shell: bash
+      id: run_claude
+      run: |
+        timeout_seconds=$((${{ inputs.timeout_minutes }} * 60))
+
+        if [ -z "${{ inputs.output_file }}" ]; then
+          timeout $timeout_seconds claude \
+            -p \
+            --verbose \
+            --output-format stream-json \
+            "$(cat ${{ env.PROMPT_PATH }})" \
+            ${{ inputs.allowed_tools != '' && format('--allowedTools "{0}"', inputs.allowed_tools) || '' }}
+        else
+          timeout $timeout_seconds claude \
+            -p \
+            --verbose \
+            --output-format stream-json \
+            "$(cat ${{ env.PROMPT_PATH }})" \
+            ${{ inputs.allowed_tools != '' && format('--allowedTools "{0}"', inputs.allowed_tools) || '' }} | tee output.txt
+
+          jq -s '.' output.txt > output.json
+          jq -r '.[-1].result' output.json > "${{ inputs.output_file }}"
+          echo "Complete output saved to output.json, final response saved to ${{ inputs.output_file }}"
+        fi
+      env:
+        ANTHROPIC_API_KEY: ${{ inputs.anthropic_api_key }}
+        GITHUB_TOKEN: ${{ inputs.github_token }}

.github/actions/claude-issue-triage-action/action.yml

@@ -1,87 +0,0 @@
-name: "Claude Issue Triage Action"
-description: "Automatically triage GitHub issues using Claude Code"
-
-inputs:
-  timeout_minutes:
-    description: "Timeout in minutes for execution"
-    required: false
-    default: "5"
-  anthropic_api_key:
-    description: "Anthropic API key"
-    required: true
-  github_token:
-    description: "GitHub token with repo and issues permissions"
-    required: true
-
-runs:
-  using: "composite"
-  steps:
-    - name: Checkout repository code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Create prompt file
-      shell: bash
-      run: |
-        mkdir -p /tmp/claude-prompts
-        cat > /tmp/claude-prompts/claude-issue-triage-prompt.txt << 'EOF'
-        You're an issue triage assistant for GitHub issues. Your task is to analyze the issue and select appropriate labels from the provided list.
-
-        IMPORTANT: Don't post any comments or messages to the issue. Your only action should be to apply labels.
-
-        Issue Information:
-        - REPO: ${{ github.repository }}
-        - ISSUE_NUMBER: ${{ github.event.issue.number }}
-
-        TASK OVERVIEW:
-
-        1. First, fetch the list of labels available in this repository by running: `gh label list`. Run exactly this command with nothing else.
-
-        2. Next, use the GitHub tools to get context about the issue:
-           - You have access to these tools:
-             - mcp__github__get_issue: Use this to retrieve the current issue's details including title, description, and existing labels
-             - mcp__github__get_issue_comments: Use this to read any discussion or additional context provided in the comments
-             - mcp__github__update_issue: Use this to apply labels to the issue (do not use this for commenting)
-             - mcp__github__search_issues: Use this to find similar issues that might provide context for proper categorization and to identify potential duplicate issues
-             - mcp__github__list_issues: Use this to understand patterns in how other issues are labeled
-           - Start by using mcp__github__get_issue to get the issue details
-
-        3. Analyze the issue content, considering:
-           - The issue title and description
-           - The type of issue (bug report, feature request, question, etc.)
-           - Technical areas mentioned
-           - Severity or priority indicators
-           - User impact
-           - Components affected
-
-        4. Select appropriate labels from the available labels list provided above:
-           - Choose labels that accurately reflect the issue's nature
-           - Be specific but comprehensive
-           - Select priority labels if you can determine urgency (high-priority, med-priority, or low-priority)
-           - Consider platform labels (android, ios) if applicable
-           - If you find similar issues using mcp__github__search_issues, consider using a "duplicate" label if appropriate. Only do so if the issue is a duplicate of another OPEN issue.
-
-        5. Apply the selected labels:
-           - Use mcp__github__update_issue to apply your selected labels
-           - DO NOT post any comments explaining your decision
-           - DO NOT communicate directly with users
-           - If no labels are clearly applicable, do not apply any labels
-
-        IMPORTANT GUIDELINES:
-        - Be thorough in your analysis
-        - Only select labels from the provided list above
-        - DO NOT post any comments to the issue
-        - Your ONLY action should be to apply labels using mcp__github__update_issue
-        - It's okay to not add any labels if none are clearly applicable
-        EOF
-
-    - name: Run Claude Code
-      uses: ./.github/actions/claude-code-action
-      with:
-        prompt_file: /tmp/claude-prompts/claude-issue-triage-prompt.txt
-        allowed_tools: "Bash(gh label list),mcp__github__get_issue,mcp__github__get_issue_comments,mcp__github__update_issue,mcp__github__search_issues,mcp__github__list_issues"
-        install_github_mcp: "true"
-        timeout_minutes: ${{ inputs.timeout_minutes }}
-        anthropic_api_key: ${{ inputs.anthropic_api_key }}
-        github_token: ${{ inputs.github_token }} 

.github/actions/gemini/action.yml

@@ -1,81 +0,0 @@
-name: 'Gemini CLI Action'
-description: 'Uses the Gemini CLI to automate software development tasks.'
-author: 'Gemini'
-
-inputs:
-  prompt:
-    description: 'A specific prompt to guide Gemini.'
-    required: false
-    default: 'You are a helpful assistant.'
-  GEMINI_API_KEY:
-    description: 'Your Gemini API key.'
-    required: true
-  OTLP_GCP_WIF_PROVIDER:
-    description: 'The workload identity provider for GCP authentication.'
-    required: false
-  OTLP_GOOGLE_CLOUD_PROJECT:
-    description: 'The Google Cloud project for telemetry.'
-    required: false
-  settings_json:
-    description: |
-      A JSON string to configure the Gemini CLI. This will be written to .gemini/settings.json.
-      To enable observability with Google Cloud, include:
-      {"telemetry": {"enabled": true, "target": "gcp"}, "sandbox": false}
-    required: false
-  version:
-    description: |
-      The version of @google/gemini-cli to execute.
-      Can be a specific version from npm (e.g., '0.1.0', 'latest'), a branch name (e.g., 'main'), or a commit hash.
-    required: false
-    default: 'latest'
-
-runs:
-  using: "composite"
-  steps:
-    - name: Configure Gemini CLI
-      if: inputs.settings_json != ''
-      run: |
-        mkdir -p .gemini
-        echo "$SETTINGS_JSON" > .gemini/settings.json
-      shell: bash
-      env:
-        SETTINGS_JSON: ${{ inputs.settings_json }}
-
-    - name: Authenticate to Google Cloud for Telemetry 
-      if: inputs.OTLP_GCP_WIF_PROVIDER != ''
-      id: auth
-      uses: 'google-github-actions/auth@v2'
-      with:
-        project_id: ${{ inputs.OTLP_GOOGLE_CLOUD_PROJECT }}
-        workload_identity_provider: ${{ inputs.OTLP_GCP_WIF_PROVIDER }}
-
-    - name: Install Gemini CLI
-      id: install
-      run: |
-        if [[ "${{ inputs.version }}" == "latest" || "${{ inputs.version }}" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9\.-]+)?(\+[a-zA-Z0-9\.-]+)?$ ]]; then
-          echo "Installing Gemini CLI from npm: @google/gemini-cli@${{ inputs.version }}"
-          npm install -g @google/gemini-cli@${{ inputs.version }}
-        else
-          echo "Installing Gemini CLI from GitHub: github:google-gemini/gemini-cli#${{ inputs.version }}"
-          npm install -g github:google-gemini/gemini-cli#${{ inputs.version }}
-        fi
-        echo "Verifying installation:"
-        if command -v gemini >/dev/null 2>&1; then
-          gemini --version || echo "Gemini CLI installed successfully (version command not available)"
-        else
-          echo "Error: Gemini CLI not found in PATH"
-          exit 1
-        fi
-      shell: bash
-
-    - name: Run Gemini CLI
-      run: |
-        gemini --yolo --prompt "$PROMPT"
-      shell: bash
-      env:
-        GEMINI_API_KEY: ${{ inputs.GEMINI_API_KEY }}
-        PROMPT: ${{ inputs.prompt }}
-
-branding:
-  icon: 'terminal'
-  color: 'blue'

.github/workflows/auto-issue-comment.yml

@@ -1,26 +0,0 @@
-name: Auto Issue Comment with PR Creation
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  add-comment:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      contents: write
-      pull-requests: write
-      actions: read
-    steps:
-      - name: Add automated comment
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GH_TOKEN }}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: '@claude review this issue and do a detailed analysis and fix this if the existing code doesn\'t have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again review the applied changes. Use @web to search if you dont know any information or to find the latest documentation or to find the latest version. Run the code if you think you need to run it to test it. Minimal code change to start with if required any changes. MAINLY IT SHOULD NOT IMPACT ON THE CURRENT SPEED OF EXECUTION of existing features, not increasing the overhead. **Please create a PR using gh tool with your changes**.'
-            })

.github/workflows/auto-pr-comment.yml

@@ -1,23 +0,0 @@
-name: Auto PR Comment
-
-on:
-  pull_request:
-    types: [opened]
-
-jobs:
-  add-comment:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - name: Add automated comment
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GH_TOKEN }}
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: '@claude review this pull request and do a detailed analysis and fix this if the existing code doesn\'t have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again review the applied changes. Use @web to search if you dont know any information or to find the latest documentation or to find the latest version. Run the code if you think you need to run it to test it. Minimal code change to start with if required any changes. MAINLY IT SHOULD NOT IMPACT ON THE CURRENT SPEED OF EXECUTION of existing features, not increasing the overhead.'
-            }) 

.github/workflows/benchmark.yml

@@ -1,145 +0,0 @@
-name: Performance Benchmarks
-
-on:
-  workflow_dispatch:
-    inputs:
-      iterations:
-        description: 'Number of benchmark iterations'
-        required: false
-        default: '100'
-      fail_on_regression:
-        description: 'Fail if performance regresses'
-        required: false
-        default: 'true'
-
-jobs:
-  benchmark:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python 3.12
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-          cache: 'pip'
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -e src/praisonai-agents[all]
-          pip install agno crewai langgraph
-
-      - name: Run Import Time Benchmark
-        id: import_time
-        run: |
-          cd src/praisonai-agents
-          python benchmarks/import_time.py 2>&1 | tee import_time_output.txt
-          
-          # Extract import time
-          IMPORT_TIME=$(grep -oP 'Median:\s+\K[\d.]+' import_time_output.txt || echo "0")
-          echo "import_time=$IMPORT_TIME" >> $GITHUB_OUTPUT
-          
-          # Check threshold (200ms)
-          if (( $(echo "$IMPORT_TIME > 200" | bc -l) )); then
-            echo "::warning::Import time ${IMPORT_TIME}ms exceeds 200ms threshold"
-            if [ "${{ inputs.fail_on_regression }}" == "true" ]; then
-              echo "import_passed=false" >> $GITHUB_OUTPUT
-            fi
-          else
-            echo "import_passed=true" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Run Memory Usage Benchmark
-        id: memory
-        run: |
-          cd src/praisonai-agents
-          python benchmarks/memory_usage.py 2>&1 | tee memory_output.txt
-          
-          # Extract peak memory
-          PEAK_MEMORY=$(grep -oP 'Peak:\s+\K[\d.]+' memory_output.txt || echo "0")
-          echo "peak_memory=$PEAK_MEMORY" >> $GITHUB_OUTPUT
-          
-          # Check threshold (30MB)
-          if (( $(echo "$PEAK_MEMORY > 30" | bc -l) )); then
-            echo "::warning::Memory usage ${PEAK_MEMORY}MB exceeds 30MB threshold"
-            if [ "${{ inputs.fail_on_regression }}" == "true" ]; then
-              echo "memory_passed=false" >> $GITHUB_OUTPUT
-            fi
-          else
-            echo "memory_passed=true" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Run Simple Benchmark
-        id: simple
-        run: |
-          cd src/praisonai-agents
-          python benchmarks/simple_benchmark.py 2>&1 | tee simple_output.txt
-          
-          # Extract PraisonAI time
-          PRAISON_TIME=$(grep -oP 'PraisonAI\s+\K[\d.]+' simple_output.txt | head -1 || echo "0")
-          echo "praison_time=$PRAISON_TIME" >> $GITHUB_OUTPUT
-
-      - name: Run Tools Benchmark
-        id: tools
-        run: |
-          cd src/praisonai-agents
-          python benchmarks/tools_benchmark.py 2>&1 | tee tools_output.txt
-          
-          # Extract PraisonAI time with tools
-          PRAISON_TOOLS_TIME=$(grep -oP 'PraisonAI\s+\K[\d.]+' tools_output.txt | head -1 || echo "0")
-          echo "praison_tools_time=$PRAISON_TOOLS_TIME" >> $GITHUB_OUTPUT
-
-      - name: Run Parameter Impact Benchmark
-        id: param_impact
-        run: |
-          cd src/praisonai-agents
-          python benchmarks/param_impact_benchmark.py --no-save --iterations ${{ inputs.iterations }} 2>&1 | tee param_impact_output.txt
-
-      - name: Check Lazy Imports
-        id: lazy_imports
-        run: |
-          cd src/praisonai-agents
-          python -c "
-          import sys
-          from praisonaiagents import Agent
-          agent = Agent(name='Test', output='silent')
-          
-          # Check litellm is NOT loaded
-          if 'litellm' in sys.modules:
-              print('FAIL: litellm loaded during silent agent creation')
-              exit(1)
-          else:
-              print('PASS: litellm not loaded (lazy import working)')
-          "
-
-      - name: Generate Benchmark Summary
-        if: always()
-        run: |
-          echo "## Performance Benchmark Results" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "| Metric | Value | Threshold | Status |" >> $GITHUB_STEP_SUMMARY
-          echo "|--------|-------|-----------|--------|" >> $GITHUB_STEP_SUMMARY
-          echo "| Import Time | ${{ steps.import_time.outputs.import_time }}ms | <200ms | ${{ steps.import_time.outputs.import_passed == 'true' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| Peak Memory | ${{ steps.memory.outputs.peak_memory }}MB | <30MB | ${{ steps.memory.outputs.memory_passed == 'true' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| Agent Instantiation | ${{ steps.simple.outputs.praison_time }}μs | - | ℹ️ |" >> $GITHUB_STEP_SUMMARY
-          echo "| Agent with Tools | ${{ steps.tools.outputs.praison_tools_time }}μs | - | ℹ️ |" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "### Lazy Import Check" >> $GITHUB_STEP_SUMMARY
-          echo "✅ litellm not loaded during silent agent creation" >> $GITHUB_STEP_SUMMARY
-
-      - name: Fail on Regression
-        if: inputs.fail_on_regression == 'true'
-        run: |
-          if [ "${{ steps.import_time.outputs.import_passed }}" == "false" ]; then
-            echo "::error::Import time regression detected"
-            exit 1
-          fi
-          if [ "${{ steps.memory.outputs.memory_passed }}" == "false" ]; then
-            echo "::error::Memory usage regression detected"
-            exit 1
-          fi
-          echo "All performance checks passed!"

.github/workflows/build-image.yml

@@ -11,7 +11,6 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
     permissions:
       contents: read
       packages: write
@@ -27,14 +26,13 @@ jobs:
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
-          password: ${{ secrets.GH_TOKEN }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
           context: ./.github/actions/claude-code-action
           push: true
-          platforms: linux/amd64
           tags: ghcr.io/mervinpraison/praisonai-claudecode:${{ inputs.version }}
           cache-from: type=gha
           cache-to: type=gha,mode=max

.github/workflows/claude-issue-triage.yml

@@ -1,23 +0,0 @@
-name: Claude Issue Triage
-description: "Automatically triage GitHub issues using Claude Code"
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  triage-issue:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4
-
-      - name: Run Claude Issue Triage
-        uses: ./.github/actions/claude-issue-triage-action
-        with:
-          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          github_token: ${{ secrets.GITHUB_TOKEN }} 

.github/workflows/claude-oauth.yml

@@ -1,21 +0,0 @@
-name: Claude OAuth
-
-on:
-  workflow_dispatch:
-    inputs:
-      code:
-        description: 'Authorization code (leave empty for step 1)'
-        required: false
-
-permissions:
-  actions: write  # Required for cache management
-  contents: read  # Required for basic repository access
-
-jobs:
-  auth:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: grll/claude-code-login@v1
-        with:
-          code: ${{ inputs.code }}
-          secrets_admin_pat: ${{ secrets.SECRETS_ADMIN_PAT }} 

.github/workflows/claude.yml

@@ -1,4 +1,4 @@
-name: Claude Assistant
+name: Claude Code
 
 on:
   issue_comment:
@@ -6,155 +6,77 @@ on:
   pull_request_review_comment:
     types: [created]
   issues:
-    types: [opened, assigned, labeled]
+    types: [opened, assigned]
   pull_request_review:
     types: [submitted]
 
 jobs:
-  claude-response:
-    # Prevent certain bots from triggering this action (but allow github-actions[bot] for auto-comments)
+  claude:
     if: |
-      github.actor != 'dependabot[bot]' &&
-      github.actor != 'cursor[bot]' &&
-      github.actor != 'renovate[bot]' &&
-      !(contains(github.actor, '[bot]') && github.actor != 'github-actions[bot]')
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
     runs-on: ubuntu-latest
     permissions:
-      contents: write
-      pull-requests: write
-      issues: write
-      actions: read
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      packages: read
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
-          fetch-depth: 0
-          
-      - uses: anthropics/claude-code-action@beta
+          fetch-depth: 1
+
+      - name: Debug Environment
+        run: |
+          echo "=== Environment Debug ==="
+          echo "GITHUB_ACTOR: $GITHUB_ACTOR"
+          echo "GITHUB_REPOSITORY: $GITHUB_REPOSITORY"
+          echo "GITHUB_REPOSITORY_OWNER: $GITHUB_REPOSITORY_OWNER"
+          echo "GITHUB_TOKEN exists: $([ -n "$GITHUB_TOKEN" ] && echo "yes" || echo "no")"
+          echo "GITHUB_TOKEN length: ${#GITHUB_TOKEN}"
+
+      - name: Check Package Visibility
+        run: |
+          echo "=== Checking Package Visibility ==="
+          curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
+               -H "Accept: application/vnd.github.v3+json" \
+               "https://api.github.com/users/MervinPraison/packages/container/praisonai-claudecode" \
+               || echo "Package API call failed"
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
         with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_ACCESS_TOKEN }}
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Test Docker Authentication
+        run: |
+          echo "=== Testing Docker Authentication ==="
+          echo "Checking ~/.docker/config.json"
+          cat ~/.docker/config.json | jq '.' || echo "No docker config found"
+          echo "=== Testing Registry Access ==="
+          curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
+               "https://ghcr.io/v2/" || echo "Registry access failed"
+
+      - name: Test Docker Pull
+        run: |
+          echo "=== Testing Docker Pull ==="
+          echo "Attempting to pull image: ghcr.io/mervinpraison/praisonai-claudecode:latest"
+          docker pull ghcr.io/mervinpraison/praisonai-claudecode:latest || echo "Pull failed with exit code: $?"
+          echo "=== Checking Docker Images ==="
+          docker images | grep praisonai-claudecode || echo "No images found"
+
+      - name: Run Claude Code
+        id: claude
+        uses: ./.github/actions/claude-code-action
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          trigger_phrase: "@claude"
-          allowed_tools: |
-            Bash(git:*)
-            Bash(python:*)
-            Bash(pip:*)
-            Bash(conda:*)
-            Bash(pytest:*)
-            Bash(gh:*)
-            Bash(python -m pytest:*)
-            Bash(python -m pip:*)
-            Bash(poetry:*)
-            View
-            GlobTool
-            GrepTool
-            BatchTool
-            Edit
-            Replace
-            mcp__github__get_issue
-            mcp__github__get_issue_comments
-            mcp__github__update_issue
-          timeout_minutes: 30
 
-  post-review-comment:
-    needs: claude-response
-    if: success() && needs.claude-response.result == 'success'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: write
-      issues: write
-    steps:
-      - name: Check for existing review comment
-        id: check-comment
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GH_TOKEN }}
-          script: |
-            const reviewText = '@claude review if the changes made in the above branch are as per the requirements and make changes to the above branch if issues still exist.';
-            let comments = [];
-            let issueNumber;
-            
-            try {
-              // Determine issue/PR number based on event type
-              if (context.eventName === 'pull_request_review_comment' || context.eventName === 'pull_request_review') {
-                issueNumber = context.payload.pull_request?.number || context.issue.number;
-              } else if (context.eventName === 'issue_comment' && context.payload.issue.pull_request) {
-                // This is a comment on a PR (not an issue)
-                issueNumber = context.payload.issue.number;
-              } else {
-                // This is a regular issue
-                issueNumber = context.issue.number;
-              }
-              
-              comments = await github.rest.issues.listComments({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber
-              });
-              
-              // Look for Claude's completed review comments
-              const claudeReviewComments = comments.data.filter(comment => 
-                (comment.user.login === 'claude[bot]' || comment.body.includes('✅') || comment.body.includes('## Summary')) &&
-                !comment.body.includes('⏳') && 
-                !comment.body.includes('🔄') &&
-                !comment.body.includes('Loading...')
-              );
-              
-              // Check if our review request comment already exists
-              const existingReviewRequest = comments.data.find(comment => 
-                comment.body.includes(reviewText)
-              );
-              
-              // Post if Claude has completed a review AND we haven't posted the review request yet
-              const shouldPost = claudeReviewComments.length > 0 && !existingReviewRequest;
-              core.setOutput('should-post', shouldPost);
-              console.log(`Claude review completed: ${claudeReviewComments.length > 0}`);
-              console.log(`Review request exists: ${!!existingReviewRequest}`);
-              console.log(`Should post comment: ${shouldPost}`);
-              
-            } catch (error) {
-              console.log('Error checking comments:', error);
-              core.setOutput('should-post', false); // If we can't check, don't post
-            }
-
-      - name: Wait 30 seconds before posting comment
-        if: steps.check-comment.outputs.should-post == 'true'
-        run: sleep 30
-
-      - name: Post review comment
-        if: steps.check-comment.outputs.should-post == 'true'
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GH_TOKEN }}
-          script: |
-            let issueNumber;
-            let isPR = false;
-            
-            // Determine issue/PR number and type based on event type
-            if (context.eventName === 'pull_request_review_comment' || context.eventName === 'pull_request_review') {
-              issueNumber = context.payload.pull_request?.number || context.issue.number;
-              isPR = true;
-            } else if (context.eventName === 'issue_comment' && context.payload.issue.pull_request) {
-              // This is a comment on a PR (not an issue)
-              issueNumber = context.payload.issue.number;
-              isPR = true;
-            } else {
-              // This is a regular issue - don't post review comment
-              issueNumber = context.issue.number;
-              isPR = false;
-            }
-            
-            // Only post review comment on PRs, not regular issues
-            if (isPR) {
-              console.log(`Posting review comment on PR #${issueNumber}`);
-              
-              await github.rest.issues.createComment({
-                issue_number: issueNumber,
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                body: '@claude review if the changes made in the above branch are as per the requirements and make changes to the above branch if issues still exist. MAINLY IT SHOULD NOT IMPACT ON THE CURRENT SPEED OF EXECUTION of existing features, not increasing the overhead.'
-              });
-            } else {
-              console.log(`Skipping review comment for regular issue #${issueNumber}`);
-            }

.github/workflows/coverage.yml

@@ -10,7 +10,6 @@ jobs:
   test:
     name: Run tests and collect coverage
     runs-on: ubuntu-latest
-    timeout-minutes: 15
     
     steps:
       - name: Checkout
@@ -41,15 +40,14 @@ jobs:
         run: |
           echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
           echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
-          echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
+          echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
           echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
           echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
 
       - name: Run tests
         run: |
           cd src/praisonai
-          # Run tests - allow some failures for now while we fix remaining issues
-          pytest --cov=praisonai --cov-branch --cov-report=xml tests/unit/ --tb=no -q || echo "Some tests failed, but coverage was collected"
+          pytest --cov=praisonai --cov-branch --cov-report=xml tests/unit/
 
       - name: Upload results to Codecov
         uses: codecov/codecov-action@v5

.github/workflows/docker-publish.yml

@@ -1,54 +1,44 @@
-name: Publish Docker
+name: Daily Publish Docker
 
 on:
-  release:
-    types: [published]
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Docker image tag (default: latest)'
-        required: false
-        default: 'latest'
+  push:
+    branches:
+      - main
+  schedule:
+    - cron: '0 0 * * *'
 
 jobs:
-  build-and-push:
+  check-and-build:
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
     
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        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
-        uses: docker/setup-buildx-action@v3
+        if: steps.check_commit.outputs.should_run == 'true'
+        uses: docker/setup-buildx-action@v1
 
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ghcr.io/mervinpraison/praisonai
-          tags: |
-            type=raw,value=latest,enable=${{ github.event_name == 'release' }}
-            type=semver,pattern={{version}},enable=${{ github.event_name == 'release' }}
-            type=semver,pattern={{major}}.{{minor}},enable=${{ github.event_name == 'release' }}
-            type=raw,value=${{ github.event.inputs.tag || 'latest' }},enable=${{ github.event_name == 'workflow_dispatch' }}
+      - 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
-        uses: docker/build-push-action@v5
+        if: steps.check_commit.outputs.should_run == 'true'
+        uses: docker/build-push-action@v2
         with:
           context: .
-          file: ./docker/Dockerfile
           push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
+          tags: ghcr.io/mervinpraison/praisonai:latest

.github/workflows/gemini-issue-automated-triage.yml

@@ -1,76 +0,0 @@
-name: Gemini Automated Issue Triage
-
-on:
-  issue_comment:
-    types: [created]
-
-jobs:
-  triage-issue:
-    if: >
-      github.event_name == 'issue_comment' &&
-      !github.event.issue.pull_request &&
-      contains(github.event.comment.body, '@gemini triage') &&
-      (github.event.comment.author_association == 'OWNER' ||
-       github.event.comment.author_association == 'MEMBER' ||
-       github.event.comment.author_association == 'COLLABORATOR')
-    timeout-minutes: 5
-    permissions:
-      issues: write
-      contents: read
-      id-token: write
-    concurrency:
-      group: ${{ github.workflow }}-${{ github.event.issue.number }}
-      cancel-in-progress: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Generate GitHub App Token
-        id: generate_token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          token: ${{ steps.generate_token.outputs.token }}
-
-      - name: Run Gemini Issue Triage
-        uses: google-gemini/gemini-cli-action@main
-        env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-          ISSUE_TITLE: ${{ github.event.issue.title }}
-          ISSUE_BODY: ${{ github.event.issue.body }}
-          ISSUE_NUMBER: ${{ github.event.issue.number }}
-          REPOSITORY: ${{ github.repository }}
-        with:
-          version: 0.1.8-rc.0
-          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
-          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
-          settings_json: |
-            {
-              "coreTools": [
-                "run_shell_command(gh label list)",
-                "run_shell_command(gh issue edit)"
-              ],
-              "telemetry": {
-                "enabled": true,
-                "target": "gcp"
-              },
-              "sandbox": false
-            }
-          prompt: |
-            You are an issue triage assistant. Analyze the current GitHub issue and apply the most appropriate existing labels.
-
-            Steps:
-            1. Run: `gh label list --limit 100` to get all available labels.
-            2. Review the issue title and body provided in the environment variables.
-            3. Select the most relevant labels from the existing labels, focusing on kind/*, area/*, and priority/*.
-            4. Apply the selected labels to this issue using: `gh issue edit ISSUE_NUMBER --add-label "label1,label2"`
-
-            Guidelines:
-            - Only use labels that already exist in the repository.
-            - Do not add comments or modify the issue content.
-            - Triage only the current issue.
-            - Assign all applicable kind/*, area/*, and priority/* labels based on the issue content.

.github/workflows/gemini-issue-review.yml

@@ -1,202 +0,0 @@
-name: Gemini Issue Review
-
-on:
-  workflow_dispatch:
-  issue_comment:
-    types: [created]
-
-permissions:
-  contents: write
-  issues: write
-  pull-requests: read
-
-jobs:
-  review-issue:
-    if: >
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'issue_comment' && 
-       !github.event.issue.pull_request && 
-       contains(github.event.comment.body, '@gemini') &&
-       !contains(github.event.comment.body, '@gemini triage') &&
-       (github.event.comment.author_association == 'OWNER' ||
-        github.event.comment.author_association == 'MEMBER' ||
-        github.event.comment.author_association == 'COLLABORATOR'))
-    runs-on: ubuntu-latest
-    env:
-      GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-    steps:
-      - name: Generate token
-        id: generate_token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          token: ${{ steps.generate_token.outputs.token }}
-
-      - name: Set up Git
-        run: |
-          git config --local user.email "[email protected]"
-          git config --local user.name "Gemini Bot"
-
-      - name: Get issue data
-        id: issue_data
-        env:
-          GH_TOKEN: ${{ steps.generate_token.outputs.token }}
-          # Pass user-controlled inputs via environment variables to prevent script injection (GHSL-2025-093)
-          EVENT_NAME: ${{ github.event_name }}
-          EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
-          EVENT_COMMENT_BODY: ${{ github.event.comment.body }}
-        run: |
-          # Get issue number from event or context
-          if [ "$EVENT_NAME" = "issue_comment" ]; then
-            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
-          elif [ "$EVENT_NAME" = "issues" ]; then
-            ISSUE_NUMBER="$EVENT_ISSUE_NUMBER"
-          else
-            echo "Unable to determine issue number"
-            exit 1
-          fi
-          
-          # Get issue details
-          gh issue view $ISSUE_NUMBER --json title,body,labels,assignees > issue_details.json
-          
-          # Extract additional instructions from comment if triggered by comment
-          ADDITIONAL_INSTRUCTIONS=""
-          if [ "$EVENT_NAME" = "issue_comment" ]; then
-            COMMENT_BODY="$EVENT_COMMENT_BODY"
-            ADDITIONAL_INSTRUCTIONS=$(echo "$COMMENT_BODY" | sed -n 's/.*@gemini[[:space:]]*\(.*\)/\1/p' | head -1)
-          fi
-          
-          echo "ISSUE_NUMBER=$ISSUE_NUMBER" >> $GITHUB_OUTPUT
-          echo "ADDITIONAL_INSTRUCTIONS=$ADDITIONAL_INSTRUCTIONS" >> $GITHUB_OUTPUT
-
-      - name: Run Gemini CLI
-        uses: ./.github/actions/gemini
-        env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-          ISSUE_NUMBER: ${{ steps.issue_data.outputs.ISSUE_NUMBER }}
-          ADDITIONAL_INSTRUCTIONS: ${{ steps.issue_data.outputs.ADDITIONAL_INSTRUCTIONS }}
-          REPOSITORY: ${{ github.repository }}
-        with:
-          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
-          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
-          prompt: |
-            You are a helpful GitHub issue assistant. Your task is to analyze and help with GitHub issues.
-            
-            **Issue Details:**
-            - Issue Number: #${ISSUE_NUMBER}
-            - Repository: ${REPOSITORY}
-            - Issue URL: ${{ github.event.issue.html_url }}
-            
-            **Additional Instructions:** ${ADDITIONAL_INSTRUCTIONS}
-            
-            **CRITICAL: When making code modifications, follow this EXACT workflow:**
-            
-            **STEP 1: Analyze the Issue**
-            - Use: `gh issue view ${ISSUE_NUMBER} --json title,body,labels,assignees`
-            - Analyze issue content thoroughly
-            - Search codebase for related files using `glob`, `search_file_content`, `list_directory`
-            
-            **STEP 2: If Code Changes Are Needed**
-            Create a new branch with 'gemini/' prefix:
-            - Use: `git checkout -b gemini/issue-${ISSUE_NUMBER}-description`
-            - Example: `git checkout -b gemini/issue-123-fix-sequential-tools`
-            
-            **STEP 3: Make Code Modifications**
-            - Use `read_file` to examine existing code
-            - Use `write_file` or `replace` to make changes
-            - Use `search_file_content` to find related code
-            - Make focused, targeted changes to fix the issue
-            
-            **STEP 4: Test Changes (if applicable)**
-            - Run relevant tests if test files exist
-            - Use `run_shell_command` to execute test commands
-            
-            **STEP 5: Commit and Push Changes**
-            - Use: `git add .` (or specific files)
-            - Use: `git commit -m "Gemini: [Issue #${ISSUE_NUMBER}] Brief description of fix"`
-            - Use: `git push -u origin gemini/issue-${ISSUE_NUMBER}-description`
-            
-            **STEP 6: Create Pull Request**
-            - Use: `gh pr create --title "Fix #${ISSUE_NUMBER}: Issue description" --body "Fixes #${ISSUE_NUMBER}\n\nSummary of changes:\n- Change 1\n- Change 2" --head gemini/issue-${ISSUE_NUMBER}-description --base main`
-            - This will return a PR URL like: https://github.com/repo/pull/123
-            
-            **STEP 7: Comment on Issue with Results**
-            Use: `gh issue comment ${ISSUE_NUMBER} -b "MESSAGE"`
-            
-            **Your final comment MUST include:**
-            - Summary of what was analyzed
-            - What changes were made (if any)
-            - Link to the created PR (if applicable)
-            - Brief explanation of the solution
-            
-            **Example final comment:**
-            ```
-            Hi! I've analyzed and fixed this issue.
-            
-            **Problem:** Sequential tool calling was getting stuck after first tool call.
-            
-            **Solution:** Added proper prompt handling after each tool call in the Ollama model integration.
-            
-            **Changes Made:**
-            - Modified `src/praisonai-agents/ollama-sequential.py`
-            - Added continuation prompts for multi-step tool execution
-            
-            **Pull Request:** https://github.com/MervinPraison/PraisonAI/pull/856
-            
-            The fix is ready for review. Please test and let me know if you encounter any issues!
-            ```
-            
-            **IMPORTANT NOTES:**
-            - Always create branches with 'gemini/' prefix
-            - Always include issue number in branch name and commit message
-            - Always create PR that references the issue
-            - Always provide PR link in your final response
-            - Use the GITHUB_TOKEN environment variable for authentication
-            
-            Please proceed with helping resolve this issue following this exact workflow.
-
-          settings_json: |
-            {
-              "coreTools": [
-                "run_shell_command(echo)",
-                "run_shell_command(gh issue view)",
-                "run_shell_command(gh issue comment)",
-                "run_shell_command(gh issue list)",
-                "run_shell_command(gh issue edit)",
-                "run_shell_command(gh pr create)",
-                "run_shell_command(gh pr view)",
-                "run_shell_command(gh pr list)",
-                "run_shell_command(cat)",
-                "run_shell_command(head)",
-                "run_shell_command(tail)",
-                "run_shell_command(grep)",
-                "run_shell_command(find)",
-                "run_shell_command(git checkout)",
-                "run_shell_command(git add)",
-                "run_shell_command(git commit)",
-                "run_shell_command(git push)",
-                "run_shell_command(git status)",
-                "run_shell_command(git branch)",
-                "list_directory",
-                "read_file",
-                "read_many_files",
-                "write_file",
-                "replace",
-                "glob",
-                "search_file_content",
-                "web_fetch",
-                "google_web_search",
-                "save_memory"
-              ],
-              "telemetry": {
-                "enabled": false,
-                "otlpGcpWifProvider": "${{ secrets.OTLP_GCP_WIF_PROVIDER }}",
-                "googleCloudProject": "${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}"
-              }
-            }

.github/workflows/gemini-pr-review.yml

@@ -1,248 +0,0 @@
-name: Gemini PR Review
-
-on:
-  issue_comment:
-    types: [created]
-  workflow_dispatch:
-    inputs:
-      pr_number:
-        description: 'PR number to review'
-        required: true
-        type: number
-
-jobs:
-  review-pr:
-    if: >
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'issue_comment' && 
-       github.event.issue.pull_request && 
-       contains(github.event.comment.body, '@gemini') &&
-       (github.event.comment.author_association == 'OWNER' ||
-        github.event.comment.author_association == 'MEMBER' ||
-        github.event.comment.author_association == 'COLLABORATOR'))
-    timeout-minutes: 15
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-      pull-requests: write
-      issues: write
-    steps:
-      - name: Generate GitHub App Token
-        id: generate_token
-        uses: actions/create-github-app-token@v1
-        with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
-
-      - name: Determine checkout ref
-        id: checkout_ref
-        run: |
-          if [ "${{ github.event_name }}" = "issue_comment" ]; then
-            echo "ref=refs/pull/${{ github.event.issue.number }}/head" >> "$GITHUB_OUTPUT"
-          else
-            echo "ref=${{ github.event.pull_request.head.sha }}" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Checkout PR code
-        uses: actions/checkout@v4
-        with:
-          token: ${{ steps.generate_token.outputs.token }}
-          ref: ${{ steps.checkout_ref.outputs.ref }}
-          fetch-depth: 0
-
-      - name: Get PR details
-        id: get_pr
-        env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-          # Pass user-controlled inputs via environment variables to prevent script injection (GHSL-2025-093)
-          EVENT_NAME: ${{ github.event_name }}
-          EVENT_INPUTS_PR_NUMBER: ${{ github.event.inputs.pr_number }}
-          EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
-          EVENT_PR_NUMBER: ${{ github.event.pull_request.number }}
-          EVENT_COMMENT_BODY: ${{ github.event.comment.body }}
-        run: |
-          if [ "$EVENT_NAME" = "workflow_dispatch" ]; then
-            PR_NUMBER=$EVENT_INPUTS_PR_NUMBER
-          elif [ "$EVENT_NAME" = "issue_comment" ]; then
-            PR_NUMBER=$EVENT_ISSUE_NUMBER
-          else
-            PR_NUMBER=$EVENT_PR_NUMBER
-          fi
-          
-          echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
-          
-          # Extract additional instructions from comment (if triggered by comment)
-          ADDITIONAL_INSTRUCTIONS=""
-          if [ "$EVENT_NAME" = "issue_comment" ]; then
-            COMMENT_BODY="$EVENT_COMMENT_BODY"
-            ADDITIONAL_INSTRUCTIONS=$(echo "$COMMENT_BODY" | sed 's/.*@gemini//' | xargs)
-          fi
-          echo "additional_instructions=$ADDITIONAL_INSTRUCTIONS" >> "$GITHUB_OUTPUT"
-          
-          # Get PR details
-          PR_DATA=$(gh pr view $PR_NUMBER --json title,body,additions,deletions,changedFiles,baseRefName,headRefName)
-          echo "pr_data=$PR_DATA" >> "$GITHUB_OUTPUT"
-          
-          # Get file changes
-          CHANGED_FILES=$(gh pr diff $PR_NUMBER --name-only)
-          echo "changed_files<<EOF" >> "$GITHUB_OUTPUT"
-          echo "$CHANGED_FILES" >> "$GITHUB_OUTPUT"
-          echo "EOF" >> "$GITHUB_OUTPUT"
-
-      - name: Run Gemini PR Review
-        uses: ./.github/actions/gemini
-        env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
-          PR_NUMBER: ${{ steps.get_pr.outputs.pr_number }}
-          PR_DATA: ${{ steps.get_pr.outputs.pr_data }}
-          CHANGED_FILES: ${{ steps.get_pr.outputs.changed_files }}
-          ADDITIONAL_INSTRUCTIONS: ${{ steps.get_pr.outputs.additional_instructions }}
-          REPOSITORY: ${{ github.repository }}
-        with:
-          version: 0.1.8-rc.0
-          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
-          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
-          settings_json: |
-            {
-              "coreTools": [
-                "run_shell_command(echo)",
-                "run_shell_command(gh pr view)",
-                "run_shell_command(gh pr diff)",
-                "run_shell_command(gh pr comment)",
-                "run_shell_command(gh pr list)",
-                "run_shell_command(cat)",
-                "run_shell_command(head)",
-                "run_shell_command(tail)",
-                "run_shell_command(grep)",
-                "run_shell_command(find)",
-                "run_shell_command(git checkout)",
-                "run_shell_command(git add)",
-                "run_shell_command(git commit)",
-                "run_shell_command(git push)",
-                "run_shell_command(git status)",
-                "run_shell_command(git branch)",
-                "run_shell_command(git fetch)",
-                "list_directory",
-                "read_file",
-                "read_many_files",
-                "write_file",
-                "replace",
-                "glob",
-                "search_file_content",
-                "web_fetch",
-                "google_web_search",
-                "save_memory"
-              ],
-              "telemetry": {
-                "enabled": false,
-                "target": "gcp"
-              },
-              "sandbox": false
-            }
-          prompt: |
-            You are an expert code reviewer and AI assistant for Pull Requests. You can review code AND make modifications to improve the PR.
-
-            **PR Details:**
-            - PR Number: #$PR_NUMBER
-            - Repository: $REPOSITORY
-            - Additional Instructions: $ADDITIONAL_INSTRUCTIONS
-
-            **CRITICAL: When making code modifications, follow this EXACT workflow:**
-
-            **STEP 1: Analyze the PR**
-            - Use: `echo "$PR_DATA"` to get PR details (JSON format)
-            - Use: `echo "$CHANGED_FILES"` to get changed files list
-            - Use: `gh pr diff ${PR_NUMBER}` to see the full diff
-            - Use: `gh pr view ${PR_NUMBER} --json title,body,headRefName` to get PR info
-            - Analyze the code changes thoroughly
-
-            **STEP 2: If Code Improvements Are Needed**
-            **IMPORTANT:** DO NOT create a new branch! Work on the EXISTING PR branch.
-            - Use: `git fetch origin` to get latest changes
-            - Get PR branch name: `gh pr view ${PR_NUMBER} --json headRefName`
-            - Switch to PR branch: `git checkout BRANCH_NAME` (use actual branch name from PR)
-            - Use: `git pull origin BRANCH_NAME` to get latest PR changes
-
-            **STEP 3: Make Code Modifications**
-            - Use `read_file` to examine existing code
-            - Use `write_file` or `replace` to make improvements
-            - Use `search_file_content` to find related code
-            - Make focused, targeted improvements to the PR
-
-            **STEP 4: Test Changes (if applicable)**
-            - Run relevant tests if test files exist
-            - Use `run_shell_command` to execute test commands
-
-            **STEP 5: Commit and Push Changes to EXISTING PR Branch**
-            - Use: `git add .` (or specific files)
-            - Use: `git commit -m "Gemini: [PR #${PR_NUMBER}] Brief description of improvements"`
-            - Use: `git push origin BRANCH_NAME` (push to EXISTING PR branch)
-
-            **STEP 6: Review and Comment on PR**
-            Write comprehensive review and post comment with your analysis and any improvements made.
-            Use: `gh pr comment ${PR_NUMBER} -b "MESSAGE"`
-
-            Review Guidelines:
-            - Focus on code quality, security, performance, and maintainability
-            - Check for common issues: potential bugs, security vulnerabilities, performance bottlenecks
-            - Verify error handling and edge cases
-            - Look for code style and best practices
-            - Comment on architecture and design decisions if significant
-            - Be constructive and specific in feedback
-            - Highlight both issues and positive aspects
-            - Suggest improvements with examples when possible
-            
-            Review Areas:
-            - **Security**: Authentication, authorization, input validation, data sanitization
-            - **Performance**: Algorithms, database queries, caching, resource usage
-            - **Reliability**: Error handling, logging, testing coverage, edge cases
-            - **Maintainability**: Code structure, documentation, naming conventions
-            - **Functionality**: Logic correctness, requirements fulfillment
-            
-            Output Format:
-            Structure your review using this exact format with markdown:
-
-            ## 📋 Review Summary
-            Provide a brief 2-3 sentence overview of the PR and overall assessment.
-
-            ## 🔍 General Feedback
-            - List general observations about code quality
-            - Mention overall patterns or architectural decisions
-            - Highlight positive aspects of the implementation
-            - Note any recurring themes across files
-
-            ## 🎯 Specific Feedback
-            Only include sections below that have actual issues. If there are no issues in a priority category, omit that entire section.
-
-            ### 🔴 Critical
-            (Only include this section if there are critical issues)
-            Issues that must be addressed before merging (security vulnerabilities, breaking changes, major bugs):
-            - **File: `filename:line`** - Description of critical issue with specific recommendation
-
-            ### 🟡 High
-            (Only include this section if there are high priority issues)
-            Important issues that should be addressed (performance problems, design flaws, significant bugs):
-            - **File: `filename:line`** - Description of high priority issue with suggested fix
-
-            ### 🟢 Medium
-            (Only include this section if there are medium priority issues)
-            Improvements that would enhance code quality (style issues, minor optimizations, better practices):
-            - **File: `filename:line`** - Description of medium priority improvement
-
-            ### 🔵 Low
-            (Only include this section if there are suggestions)
-            Nice-to-have improvements and suggestions (documentation, naming, minor refactoring):
-            - **File: `filename:line`** - Description of suggestion or enhancement
-
-            **Note**: If no specific issues are found in any category, simply state "No specific issues identified in this review."
-
-            ## ✅ Highlights
-            (Only include this section if there are positive aspects to highlight)
-            - Mention specific good practices or implementations
-            - Acknowledge well-written code sections
-            - Note improvements from previous versions
-
-            ---
-            *Review completed by Gemini CLI*

.github/workflows/python-package.yml

@@ -29,7 +29,7 @@ jobs:
       run: |
         echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
         echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
-        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
         echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
 
     - name: Install dependencies

.github/workflows/test-comprehensive.yml

@@ -26,10 +26,6 @@ on:
 jobs:
   comprehensive-test:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      OPENAI_MODEL_NAME: gpt-4o-mini
     strategy:
       matrix:
         python-version: ["3.11"]
@@ -54,17 +50,15 @@ jobs:
         cd src/praisonai
         uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
         uv pip install --system duckduckgo_search
-        uv pip install --system pytest pytest-asyncio pytest-cov pytest-benchmark pytest-timeout
+        uv pip install --system pytest pytest-asyncio pytest-cov pytest-benchmark
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
-    - name: Verify environment variables
+    - name: Set environment variables
       run: |
-        if [ -n "$OPENAI_API_KEY" ]; then
-          echo "✅ OPENAI_API_KEY is set (length: ${#OPENAI_API_KEY})"
-        else
-          echo "⚠️ OPENAI_API_KEY is NOT set"
-        fi
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
 
     - name: Run Comprehensive Test Suite
       run: |
@@ -75,28 +69,28 @@ jobs:
         
         case $TEST_TYPE in
           "unit")
-            cd src/praisonai && python -m pytest tests/unit/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=xml --cov-branch || echo "Some unit tests failed"
+            cd src/praisonai && python -m pytest tests/unit/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=xml --cov-branch
             ;;
           "integration")
-            cd src/praisonai && python -m pytest tests/integration/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=xml --cov-branch || echo "Some integration tests failed"
+            cd src/praisonai && python -m pytest tests/integration/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=xml --cov-branch
             ;;
           "fast")
-            cd src/praisonai && python tests/test_runner.py --pattern fast || echo "Some fast tests failed"
+            cd src/praisonai && python tests/test_runner.py --pattern fast
             ;;
           "performance")
-            cd src/praisonai && python tests/test_runner.py --pattern "performance" || echo "Some performance tests failed"
+            cd src/praisonai && python tests/test_runner.py --pattern "performance"
             ;;
           "frameworks")
-            cd src/praisonai && python tests/test_runner.py --pattern frameworks || echo "Some framework tests failed"
+            cd src/praisonai && python tests/test_runner.py --pattern frameworks
             ;;
           "autogen")
-            cd src/praisonai && python tests/test_runner.py --pattern autogen || echo "Some autogen tests failed"
+            cd src/praisonai && python tests/test_runner.py --pattern autogen
             ;;
           "crewai")
-            cd src/praisonai && python tests/test_runner.py --pattern crewai || echo "Some crewai tests failed"
+            cd src/praisonai && python tests/test_runner.py --pattern crewai
             ;;
           "all"|*)
-            cd src/praisonai && python tests/test_runner.py --pattern all || echo "Some tests failed"
+            cd src/praisonai && python tests/test_runner.py --pattern all
             ;;
         esac
 

.github/workflows/test-core.yml

@@ -9,7 +9,6 @@ on:
 jobs:
   test-core:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
     strategy:
       matrix:
         python-version: [3.11]
@@ -34,7 +33,7 @@ jobs:
         cd src/praisonai
         uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
         uv pip install --system duckduckgo_search
-        uv pip install --system pytest pytest-asyncio pytest-cov pytest-timeout
+        uv pip install --system pytest pytest-asyncio pytest-cov
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
@@ -42,13 +41,13 @@ jobs:
       run: |
         echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
         echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
-        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
         echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
         echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
         # Also export to current shell session for immediate availability
         export OPENAI_API_KEY="${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}"
         export OPENAI_API_BASE="${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}"
-        export OPENAI_MODEL_NAME="${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}"
+        export OPENAI_MODEL_NAME="${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}"
         export LOGLEVEL=DEBUG
         # Verify immediate availability
         echo "🔧 Immediate verification in same step:"
@@ -126,7 +125,7 @@ jobs:
       env:
         OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}
         OPENAI_API_BASE: ${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}
-        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}
+        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}
         LOGLEVEL: DEBUG
       run: |
         echo "🔍 Testing PraisonAI API key usage directly..."
@@ -152,7 +151,7 @@ jobs:
             return 'INVALID_TYPE'
 
         print('🔧 Direct PraisonAI API Key Check:')
-        env_api_key = os.environ.get(\"OPENAI_API_KEY\", \"NOT_SET\")
+        env_api_key = os.environ.get(\\"OPENAI_API_KEY\\", \\"NOT_SET\\")
         print(f'Environment OPENAI_API_KEY: {get_key_display_value(env_api_key)}...')
         
         from praisonai import PraisonAI
@@ -164,9 +163,9 @@ jobs:
         
         from praisonai.inc.models import PraisonAIModel
         
-        print('\\n🧪 Testing PraisonAIModel with explicit API key (CrewAI method):')
+        print('\\\\n🧪 Testing PraisonAIModel with explicit API key (CrewAI method):')
         model_with_explicit_key = PraisonAIModel(
-            model='openai/gpt-5-nano',
+            model='openai/gpt-4o-mini',
             base_url=praisonai.config_list[0].get('base_url'),
             api_key=api_key_from_config # This will be a string from praisonai.config_list
         )
@@ -196,8 +195,7 @@ jobs:
 
     - name: Run Unit Tests
       run: |
-        cd src/praisonai && python -m pytest tests/unit/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=term-missing --cov-report=xml --cov-branch || echo "Some tests failed - see output above"
-      continue-on-error: true
+        cd src/praisonai && python -m pytest tests/unit/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=term-missing --cov-report=xml --cov-branch
 
     - name: Run Integration Tests  
       run: |
@@ -252,7 +250,7 @@ jobs:
       env:
         OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}
         OPENAI_API_BASE: ${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}
-        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}
+        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}
         LOGLEVEL: DEBUG
       run: |
         echo "🧪 Running legacy tests with real API key..."
@@ -263,7 +261,7 @@ jobs:
         export OPENAI_API_KEY="$OPENAI_API_KEY"
         export OPENAI_API_BASE="$OPENAI_API_BASE"
         export OPENAI_MODEL_NAME="$OPENAI_MODEL_NAME"
-        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings -m "not real" --timeout=60
+        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings
 
     - name: Upload coverage reports to Codecov
       if: matrix.python-version == '3.11'

.github/workflows/test-extended.yml

@@ -13,7 +13,6 @@ on:
 jobs:
   test-examples:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
     
     steps:
     - name: Checkout code
@@ -42,11 +41,8 @@ jobs:
       run: |
         echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
         echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
-        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
         echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
-        echo "PRAISONAI_TELEMETRY_DISABLED=true" >> $GITHUB_ENV
-        echo "PRAISONAI_DISABLE_TELEMETRY=true" >> $GITHUB_ENV
-        echo "DO_NOT_TRACK=true" >> $GITHUB_ENV
 
     - name: Test Key Example Scripts
       run: |
@@ -77,7 +73,6 @@ jobs:
 
   performance-test:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
     
     steps:
     - name: Checkout code
@@ -102,12 +97,6 @@ jobs:
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
-    - name: Set environment variables
-      run: |
-        echo "PRAISONAI_TELEMETRY_DISABLED=true" >> $GITHUB_ENV
-        echo "PRAISONAI_DISABLE_TELEMETRY=true" >> $GITHUB_ENV
-        echo "DO_NOT_TRACK=true" >> $GITHUB_ENV
-
     - name: Run Performance Benchmarks
       run: |
         echo "🏃 Running performance benchmarks..."
@@ -172,4 +161,4 @@ jobs:
       with:
         name: performance-report
         path: performance_report.md
-        retention-days: 5
+        retention-days: 30 

.github/workflows/test-frameworks.yml

@@ -24,7 +24,6 @@ on:
 jobs:
   framework-tests:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
     strategy:
       matrix:
         python-version: [3.11]
@@ -50,13 +49,13 @@ jobs:
         cd src/praisonai
         uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
         uv pip install --system duckduckgo_search
-        uv pip install --system pytest pytest-asyncio pytest-cov pytest-timeout
+        uv pip install --system pytest pytest-asyncio pytest-cov
 
     - name: Set environment variables
       run: |
         echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
         echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
-        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
 
     - name: Test ${{ matrix.framework }} Framework
       run: |

.github/workflows/test-optimized.yml

@@ -1,530 +0,0 @@
-name: Optimized Test Suite
-
-on: 
-  push:
-    branches: [ main, develop ]
-  pull_request:
-    branches: [ main, develop ]
-  schedule:
-    # Nightly extended tests at 3 AM UTC
-    - cron: '0 3 * * *'
-  workflow_dispatch:
-    inputs:
-      tier:
-        description: 'Test tier to run'
-        required: true
-        default: 'main'
-        type: choice
-        options:
-          - smoke
-          - main
-          - extended
-          - nightly
-
-env:
-  PYTHONPATH: ${{ github.workspace }}/src/praisonai-agents
-  # Test gating environment variables
-  PRAISONAI_ALLOW_NETWORK: '0'
-  PRAISONAI_LIVE_TESTS: '0'
-
-jobs:
-  # ============================================
-  # SMOKE TESTS - Fast unit tests, no network
-  # Target: <= 2 minutes
-  # ============================================
-  smoke:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Set up Python 3.11
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Cache pip packages
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-smoke-${{ hashFiles('**/pyproject.toml') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-smoke-
-          ${{ runner.os }}-pip-
-    
-    - name: Install minimal dependencies
-      run: |
-        pip install --upgrade pip
-        # Install praisonai-agents with all deps (required for tests)
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e ".[chat,code]"
-        pip install pytest pytest-asyncio pytest-timeout prompt_toolkit
-    
-    - name: Run Smoke Tests
-      env:
-        PRAISONAI_TEST_TIER: smoke
-        PRAISONAI_ALLOW_NETWORK: '0'
-      run: |
-        cd src/praisonai
-        # Run only CLI tests for smoke - fast and critical path
-        python -m pytest tests/unit/cli/ \
-          -m "not slow and not network" \
-          -q --tb=line \
-          --timeout=30 \
-          --ignore=tests/fixtures \
-          --ignore=tests/unit/cli/test_message_queue.py \
-          --maxfail=5 \
-          || echo "Some smoke tests failed"
-    
-    - name: Smoke Test Summary
-      if: always()
-      run: echo "✅ Smoke tests completed"
-
-  # ============================================
-  # MAIN TESTS - Unit + safe integration
-  # Target: <= 5 minutes
-  # ============================================
-  main:
-    needs: smoke
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    strategy:
-      matrix:
-        python-version: ['3.11']
-    
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-    
-    - name: Cache pip packages
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-main-${{ hashFiles('**/pyproject.toml') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-main-
-          ${{ runner.os }}-pip-
-    
-    - name: Install dependencies
-      run: |
-        pip install --upgrade pip
-        # Install praisonai-agents with all deps (required for tests)
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e ".[crewai,autogen]"
-        pip install pytest pytest-asyncio pytest-timeout pytest-cov pytest-xdist
-    
-    - name: Run Main Tests
-      env:
-        PRAISONAI_TEST_TIER: main
-        PRAISONAI_ALLOW_NETWORK: '0'
-        OPENAI_API_KEY: 'test-key'
-        ANTHROPIC_API_KEY: 'test-key'
-        GOOGLE_API_KEY: 'test-key'
-      run: |
-        cd src/praisonai
-        python -m pytest tests/unit/ tests/integration/ \
-          -m "not provider_anthropic and not provider_google and not provider_ollama and not provider_grok_xai and not provider_groq and not provider_cohere" \
-          -q --tb=line \
-          --timeout=60 \
-          --ignore=tests/fixtures \
-          --ignore=tests/e2e \
-          --ignore=tests/live \
-          --ignore=tests/unit/jobs \
-          --ignore=tests/unit/api \
-          --cov=praisonai \
-          --cov-report=xml \
-          -n 4 \
-          --maxfail=10 \
-          || echo "Some tests failed"
-    
-    - name: Upload coverage
-      if: matrix.python-version == '3.11'
-      uses: codecov/codecov-action@v5
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        file: src/praisonai/coverage.xml
-        flags: main-tests
-        fail_ci_if_error: false
-
-  # ============================================
-  # OPENAI LIVE TESTS - Real OpenAI API calls
-  # Only runs if OPENAI_API_KEY secret is set
-  # Safe for forks (skips gracefully if no key)
-  # ============================================
-  openai-live:
-    needs: smoke
-    runs-on: ubuntu-latest
-    timeout-minutes: 8
-    # This job always runs but steps are conditional on secret availability
-    
-    steps:
-    - name: Check if OpenAI key is available
-      id: check-key
-      run: |
-        if [ -n "${{ secrets.OPENAI_API_KEY }}" ]; then
-          echo "has_key=true" >> $GITHUB_OUTPUT
-        else
-          echo "has_key=false" >> $GITHUB_OUTPUT
-          echo "⚠️ OPENAI_API_KEY not set - skipping live tests"
-        fi
-    
-    - uses: actions/checkout@v4
-      if: steps.check-key.outputs.has_key == 'true'
-    
-    - name: Set up Python 3.11
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Cache pip packages
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-openai-${{ hashFiles('**/pyproject.toml') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
-    
-    - name: Install dependencies
-      if: steps.check-key.outputs.has_key == 'true'
-      run: |
-        pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e ".[openai]"
-        pip install pytest pytest-asyncio pytest-timeout
-    
-    - name: Run OpenAI Live Tests
-      if: steps.check-key.outputs.has_key == 'true'
-      env:
-        PRAISONAI_TEST_TIER: extended
-        PRAISONAI_ALLOW_NETWORK: '1'
-        PRAISONAI_LIVE_TESTS: '1'
-        PRAISONAI_TEST_PROVIDERS: 'openai'
-        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}
-      run: |
-        cd src/praisonai
-        python -m pytest tests/ \
-          -m "provider_openai or real" \
-          -v --tb=short \
-          --timeout=120 \
-          --ignore=tests/fixtures \
-          || echo "Some OpenAI tests failed"
-    
-    - name: Skip notice
-      if: steps.check-key.outputs.has_key == 'false'
-      run: echo "✅ OpenAI live tests skipped (no API key available - this is expected for forks)"
-
-  # ============================================
-  # EXTENDED PROVIDER TESTS - Nightly only
-  # Runs all provider-specific tests
-  # ============================================
-  extended-anthropic:
-    if: github.event_name == 'schedule' || github.event.inputs.tier == 'extended' || github.event.inputs.tier == 'nightly'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    
-    steps:
-    - name: Check if Anthropic key is available
-      id: check-key
-      run: |
-        if [ -n "${{ secrets.ANTHROPIC_API_KEY }}" ]; then
-          echo "has_key=true" >> $GITHUB_OUTPUT
-        else
-          echo "has_key=false" >> $GITHUB_OUTPUT
-          echo "⚠️ ANTHROPIC_API_KEY not set - skipping tests"
-        fi
-    
-    - uses: actions/checkout@v4
-      if: steps.check-key.outputs.has_key == 'true'
-    
-    - name: Set up Python 3.11
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      if: steps.check-key.outputs.has_key == 'true'
-      run: |
-        pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e ".[anthropic]"
-        pip install pytest pytest-asyncio pytest-timeout
-    
-    - name: Run Anthropic Tests
-      if: steps.check-key.outputs.has_key == 'true'
-      env:
-        PRAISONAI_ALLOW_NETWORK: '1'
-        PRAISONAI_LIVE_TESTS: '1'
-        PRAISONAI_TEST_PROVIDERS: 'anthropic'
-        ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-      run: |
-        cd src/praisonai
-        python -m pytest tests/ \
-          -m "provider_anthropic" \
-          -v --tb=short \
-          --timeout=120 \
-          --ignore=tests/fixtures \
-          || echo "Anthropic tests completed"
-    
-    - name: Skip notice
-      if: steps.check-key.outputs.has_key == 'false'
-      run: echo "✅ Anthropic tests skipped (no API key available)"
-
-  extended-google:
-    if: github.event_name == 'schedule' || github.event.inputs.tier == 'extended' || github.event.inputs.tier == 'nightly'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    
-    steps:
-    - name: Check if Google key is available
-      id: check-key
-      run: |
-        if [ -n "${{ secrets.GOOGLE_API_KEY }}" ]; then
-          echo "has_key=true" >> $GITHUB_OUTPUT
-        else
-          echo "has_key=false" >> $GITHUB_OUTPUT
-          echo "⚠️ GOOGLE_API_KEY not set - skipping tests"
-        fi
-    
-    - uses: actions/checkout@v4
-      if: steps.check-key.outputs.has_key == 'true'
-    
-    - name: Set up Python 3.11
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      if: steps.check-key.outputs.has_key == 'true'
-      run: |
-        pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e ".[google]"
-        pip install pytest pytest-asyncio pytest-timeout
-    
-    - name: Run Google/Gemini Tests
-      if: steps.check-key.outputs.has_key == 'true'
-      env:
-        PRAISONAI_ALLOW_NETWORK: '1'
-        PRAISONAI_LIVE_TESTS: '1'
-        PRAISONAI_TEST_PROVIDERS: 'google'
-        GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
-      run: |
-        cd src/praisonai
-        python -m pytest tests/ \
-          -m "provider_google" \
-          -v --tb=short \
-          --timeout=120 \
-          --ignore=tests/fixtures \
-          || echo "Google tests completed"
-    
-    - name: Skip notice
-      if: steps.check-key.outputs.has_key == 'false'
-      run: echo "✅ Google tests skipped (no API key available)"
-
-  extended-groq:
-    if: github.event_name == 'schedule' || github.event.inputs.tier == 'extended' || github.event.inputs.tier == 'nightly'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    
-    steps:
-    - name: Check if Groq key is available
-      id: check-key
-      run: |
-        if [ -n "${{ secrets.GROQ_API_KEY }}" ]; then
-          echo "has_key=true" >> $GITHUB_OUTPUT
-        else
-          echo "has_key=false" >> $GITHUB_OUTPUT
-          echo "⚠️ GROQ_API_KEY not set - skipping tests"
-        fi
-    
-    - uses: actions/checkout@v4
-      if: steps.check-key.outputs.has_key == 'true'
-    
-    - name: Set up Python 3.11
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      if: steps.check-key.outputs.has_key == 'true'
-      run: |
-        pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e .
-        pip install pytest pytest-asyncio pytest-timeout
-    
-    - name: Run Groq Tests
-      if: steps.check-key.outputs.has_key == 'true'
-      env:
-        PRAISONAI_ALLOW_NETWORK: '1'
-        PRAISONAI_LIVE_TESTS: '1'
-        PRAISONAI_TEST_PROVIDERS: 'groq'
-        GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
-      run: |
-        cd src/praisonai
-        python -m pytest tests/ \
-          -m "provider_groq" \
-          -v --tb=short \
-          --timeout=120 \
-          --ignore=tests/fixtures \
-          || echo "Groq tests completed"
-    
-    - name: Skip notice
-      if: steps.check-key.outputs.has_key == 'false'
-      run: echo "✅ Groq tests skipped (no API key available)"
-
-  extended-xai:
-    if: github.event_name == 'schedule' || github.event.inputs.tier == 'extended' || github.event.inputs.tier == 'nightly'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    
-    steps:
-    - name: Check if xAI key is available
-      id: check-key
-      run: |
-        if [ -n "${{ secrets.XAI_API_KEY }}" ]; then
-          echo "has_key=true" >> $GITHUB_OUTPUT
-        else
-          echo "has_key=false" >> $GITHUB_OUTPUT
-          echo "⚠️ XAI_API_KEY not set - skipping tests"
-        fi
-    
-    - uses: actions/checkout@v4
-      if: steps.check-key.outputs.has_key == 'true'
-    
-    - name: Set up Python 3.11
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      if: steps.check-key.outputs.has_key == 'true'
-      run: |
-        pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e .
-        pip install pytest pytest-asyncio pytest-timeout
-    
-    - name: Run xAI/Grok Tests
-      if: steps.check-key.outputs.has_key == 'true'
-      env:
-        PRAISONAI_ALLOW_NETWORK: '1'
-        PRAISONAI_LIVE_TESTS: '1'
-        PRAISONAI_TEST_PROVIDERS: 'grok_xai'
-        XAI_API_KEY: ${{ secrets.XAI_API_KEY }}
-      run: |
-        cd src/praisonai
-        python -m pytest tests/ \
-          -m "provider_grok_xai" \
-          -v --tb=short \
-          --timeout=120 \
-          --ignore=tests/fixtures \
-          || echo "xAI tests completed"
-    
-    - name: Skip notice
-      if: steps.check-key.outputs.has_key == 'false'
-      run: echo "✅ xAI tests skipped (no API key available)"
-
-  extended-cohere:
-    if: github.event_name == 'schedule' || github.event.inputs.tier == 'extended' || github.event.inputs.tier == 'nightly'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    
-    steps:
-    - name: Check if Cohere key is available
-      id: check-key
-      run: |
-        if [ -n "${{ secrets.COHERE_API_KEY }}" ]; then
-          echo "has_key=true" >> $GITHUB_OUTPUT
-        else
-          echo "has_key=false" >> $GITHUB_OUTPUT
-          echo "⚠️ COHERE_API_KEY not set - skipping tests"
-        fi
-    
-    - uses: actions/checkout@v4
-      if: steps.check-key.outputs.has_key == 'true'
-    
-    - name: Set up Python 3.11
-      if: steps.check-key.outputs.has_key == 'true'
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-    
-    - name: Install dependencies
-      if: steps.check-key.outputs.has_key == 'true'
-      run: |
-        pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install -e ".[all]"
-        cd ../praisonai
-        pip install -e ".[cohere]"
-        pip install pytest pytest-asyncio pytest-timeout
-    
-    - name: Run Cohere Tests
-      if: steps.check-key.outputs.has_key == 'true'
-      env:
-        PRAISONAI_ALLOW_NETWORK: '1'
-        PRAISONAI_LIVE_TESTS: '1'
-        PRAISONAI_TEST_PROVIDERS: 'cohere'
-        COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
-      run: |
-        cd src/praisonai
-        python -m pytest tests/ \
-          -m "provider_cohere" \
-          -v --tb=short \
-          --timeout=120 \
-          --ignore=tests/fixtures \
-          || echo "Cohere tests completed"
-    
-    - name: Skip notice
-      if: steps.check-key.outputs.has_key == 'false'
-      run: echo "✅ Cohere tests skipped (no API key available)"
-
-  # ============================================
-  # TEST SUMMARY
-  # ============================================
-  test-summary:
-    needs: [smoke, main]
-    if: always()
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Test Summary
-      run: |
-        echo "# 📊 Test Suite Summary" >> $GITHUB_STEP_SUMMARY
-        echo "" >> $GITHUB_STEP_SUMMARY
-        echo "| Job | Status |" >> $GITHUB_STEP_SUMMARY
-        echo "|-----|--------|" >> $GITHUB_STEP_SUMMARY
-        echo "| Smoke | ${{ needs.smoke.result }} |" >> $GITHUB_STEP_SUMMARY
-        echo "| Main | ${{ needs.main.result }} |" >> $GITHUB_STEP_SUMMARY
-        echo "" >> $GITHUB_STEP_SUMMARY
-        echo "## Test Tiers" >> $GITHUB_STEP_SUMMARY
-        echo "- **smoke**: Fast unit tests, no network (≤2 min)" >> $GITHUB_STEP_SUMMARY
-        echo "- **main**: Unit + integration, no network (≤5 min)" >> $GITHUB_STEP_SUMMARY
-        echo "- **openai-live**: OpenAI API tests (when key available)" >> $GITHUB_STEP_SUMMARY
-        echo "- **extended-***: Provider-specific tests (nightly)" >> $GITHUB_STEP_SUMMARY

.github/workflows/test-real.yml

@@ -26,7 +26,6 @@ jobs:
   real-tests:
     runs-on: ubuntu-latest
     if: ${{ github.event.inputs.confirm_costs == 'true' && github.event.inputs.framework != 'none' }}
-    timeout-minutes: 15
     
     strategy:
       matrix:

.github/workflows/test-windows.yml

@@ -1,204 +0,0 @@
-name: Windows Tests
-
-on:
-  push:
-    branches: [main, develop]
-  pull_request:
-    branches: [main, develop]
-  workflow_dispatch:
-
-jobs:
-  test-windows:
-    runs-on: windows-latest
-    timeout-minutes: 5
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-      OPENAI_MODEL_NAME: gpt-4o-mini
-    
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Set up Python 3.11
-      uses: actions/setup-python@v5
-      with:
-        python-version: "3.11"
-    
-    - name: Install praisonaiagents
-      run: |
-        python -m pip install --upgrade pip
-        cd src/praisonai-agents
-        pip install .
-      shell: bash
-    
-    - name: Install praisonai wrapper
-      run: |
-        cd src/praisonai
-        pip install .[dev]
-      shell: bash
-
-    # ==================== CORE IMPORTS ====================
-    - name: Test core imports
-      run: |
-        python -c "from praisonaiagents import Agent, Agents, Workflow; print('Core imports OK')"
-        python -c "from praisonaiagents import tool, Tools; print('Tool imports OK')"
-        python -c "from praisonaiagents import Task, WorkflowStep; print('Task/Step imports OK')"
-
-    # ==================== AGENT FEATURES ====================
-    - name: Test Agent instantiation
-      run: |
-        python -c "
-        from praisonaiagents import Agent
-        a = Agent(name='Test', instructions='You are helpful')
-        print('Agent created:', a.name)
-        a2 = Agent(name='ToolAgent', instructions='Use tools', tools=[])
-        print('Agent with tools:', a2.name)
-        "
-
-    - name: Test Agents orchestration
-      run: |
-        python -c "
-        from praisonaiagents import Agent, Agents, Task
-        a1 = Agent(name='Agent1', instructions='First agent')
-        a2 = Agent(name='Agent2', instructions='Second agent')
-        t = Task(description='Do something', agent=a1)
-        agents = Agents(agents=[a1, a2], tasks=[t])
-        print('Agents:', len(agents.agents), 'Tasks:', len(agents.tasks))
-        "
-
-    # ==================== WORKFLOW FEATURES ====================
-    - name: Test Workflow and WorkflowStep
-      run: |
-        python -c "
-        from praisonaiagents import Workflow, WorkflowStep
-        from praisonaiagents.workflows import WorkflowOutputConfig
-        
-        w = Workflow(name='test')
-        s1 = WorkflowStep(name='step1')
-        s2 = WorkflowStep(name='step2', context=['step1'])
-        print('Workflow:', w.name)
-        print('Steps:', s1.name, s2.name)
-        
-        cfg = WorkflowOutputConfig(verbose=True, stream=False)
-        w2 = Workflow(name='configured', output=cfg)
-        print('Configured workflow verbose:', w2.verbose)
-        "
-
-    # ==================== MEMORY FEATURES ====================
-    - name: Test Memory classes
-      run: |
-        python -c "
-        from praisonaiagents.memory import FileMemory
-        from praisonaiagents.config import MemoryConfig
-        
-        cfg = MemoryConfig(backend='file', user_id='test_user')
-        print('MemoryConfig backend:', cfg.backend)
-        
-        mem = FileMemory(user_id='test_user', base_path='.praison/test_memory')
-        print('FileMemory user:', mem.user_id)
-        "
-
-    # ==================== TOOL DECORATOR ====================
-    - name: Test tool decorator
-      run: |
-        python -c "
-        from praisonaiagents import tool
-        
-        @tool
-        def my_tool(query: str) -> str:
-            '''A test tool'''
-            return f'Echo: {query}'
-        
-        result = my_tool('hello')
-        print('Tool result:', result)
-        "
-
-    # ==================== CONFIG CLASSES ====================
-    - name: Test config classes
-      run: |
-        python -c "
-        from praisonaiagents.config import OutputConfig, ExecutionConfig, PlanningConfig
-        
-        out_cfg = OutputConfig(verbose=True, stream=True)
-        print('OutputConfig verbose:', out_cfg.verbose)
-        
-        exec_cfg = ExecutionConfig(max_iter=50, max_retry_limit=5)
-        print('ExecutionConfig max_iter:', exec_cfg.max_iter)
-        
-        plan_cfg = PlanningConfig(reasoning=True, auto_approve=False)
-        print('PlanningConfig reasoning:', plan_cfg.reasoning)
-        "
-    # ==================== HANDOFF ====================
-    - name: Test Handoff
-      run: |
-        python -c "
-        from praisonaiagents import Handoff, handoff, Agent
-        
-        a1 = Agent(name='Agent1', instructions='First')
-        a2 = Agent(name='Agent2', instructions='Second')
-        
-        # Using Handoff class directly
-        h = Handoff(agent=a2)
-        print('Handoff tool name:', h.tool_name)
-        
-        # Using handoff function
-        h2 = handoff(a1, tool_name_override='custom_handoff')
-        print('Custom handoff name:', h2.tool_name)
-        "
-
-
-    # ==================== ASYNC FEATURES ====================
-    - name: Test async imports
-      run: |
-        python -c "
-        import asyncio
-        from praisonaiagents import Agent
-        
-        async def test_async():
-            agent = Agent(name='AsyncAgent', instructions='Test')
-            assert hasattr(agent, 'arun'), 'Missing arun'
-            assert hasattr(agent, 'astart'), 'Missing astart'
-            print('Async methods available')
-        
-        asyncio.run(test_async())
-        "
-
-    # ==================== CLI COMMANDS ====================
-    - name: Test CLI help
-      run: praisonai --help
-
-    - name: Test CLI session list
-      run: praisonai session list
-      continue-on-error: true
-
-    - name: Test CLI queue list
-      run: praisonai queue list
-      continue-on-error: true
-
-    # ==================== REAL API TESTS ====================
-    - name: Real API test - Agent run
-      if: env.OPENAI_API_KEY != ''
-      run: |
-        python -c "
-        from praisonaiagents import Agent
-        agent = Agent(name='TestAgent', instructions='Reply with exactly: WINDOWS_OK', llm='gpt-4o-mini')
-        result = agent.run('Say WINDOWS_OK')
-        print('Result:', result)
-        print('Real API test passed')
-        "
-
-    - name: Real API test - Multi-agent
-      if: env.OPENAI_API_KEY != ''
-      run: |
-        python -c "
-        from praisonaiagents import Agent, Agents, Task
-        
-        researcher = Agent(name='Researcher', instructions='You research topics', llm='gpt-4o-mini')
-        writer = Agent(name='Writer', instructions='You write content', llm='gpt-4o-mini')
-        
-        task = Task(description='Say hello world', agent=researcher)
-        
-        agents = Agents(agents=[researcher, writer], tasks=[task])
-        result = agents.start()
-        print('Multi-agent result type:', type(result))
-        print('Multi-agent test passed')
-        "

.github/workflows/unittest.yml

@@ -5,7 +5,6 @@ on: [push, pull_request]
 jobs:
   quick-test:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
 
     steps:
     - name: Checkout code
@@ -27,7 +26,7 @@ jobs:
         cd src/praisonai
         uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
         uv pip install --system duckduckgo_search
-        uv pip install --system pytest pytest-asyncio pytest-cov pytest-timeout
+        uv pip install --system pytest pytest-asyncio pytest-cov
         # Install knowledge dependencies from praisonai-agents
         uv pip install --system "praisonaiagents[knowledge]"
 
@@ -35,7 +34,7 @@ jobs:
       run: |
         echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
         echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
-        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-5-nano' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
         echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
         echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
 
@@ -316,8 +315,8 @@ jobs:
         try:
             from praisonai.inc.models import PraisonAIModel
             
-            # Test PraisonAIModel with openai/gpt-5-nano (from YAML)
-            model = PraisonAIModel(model='openai/gpt-5-nano')
+            # Test PraisonAIModel with openai/gpt-4o-mini (from YAML)
+            model = PraisonAIModel(model='openai/gpt-4o-mini')
             
             print('🤖 PraisonAIModel Configuration:')
             print(f'  model: {model.model}')
@@ -489,7 +488,7 @@ jobs:
 
     - name: Run Legacy Example Tests
       run: |
-        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings -m "not real" --timeout=60
+        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings
       continue-on-error: true
 
     - name: Upload coverage reports to Codecov

.github/workflows/update-api-md.yml

@@ -1,57 +0,0 @@
-name: Update API Reference
-
-on:
-  push:
-    branches: [ "main" ]
-    paths:
-      - 'src/praisonai-agents/praisonaiagents/**/*.py'
-      - 'src/praisonai/praisonai/**/*.py'
-      - 'src/praisonai-ts/src/**/*.ts'
-      - '.github/workflows/update-api-md.yml'
-
-permissions:
-  contents: write
-
-jobs:
-  update-api-md:
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-      with:
-        ref: main
-        persist-credentials: true
-        fetch-depth: 0
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-
-    - name: Generate api.md
-      run: |
-        cd $GITHUB_WORKSPACE
-        python3 src/praisonai/scripts/generate_api_md.py
-        
-    - name: Check for changes
-      id: check_changes
-      run: |
-        if git diff --quiet api.md; then
-          echo "changes=false" >> $GITHUB_OUTPUT
-          echo "No changes to api.md"
-        else
-          echo "changes=true" >> $GITHUB_OUTPUT
-          echo "api.md has been updated"
-          git diff api.md | head -50
-        fi
-
-    - name: Commit and push changes
-      if: steps.check_changes.outputs.changes == 'true'
-      uses: stefanzweifel/git-auto-commit-action@v5
-      with:
-        commit_message: "docs: auto-update api.md [skip ci]"
-        file_pattern: 'api.md'
-        commit_user_name: "github-actions[bot]"
-        commit_user_email: "41898282+github-actions[bot]@users.noreply.github.com"
-        commit_author: "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"

.github/workflows/update-docs-parity.yml

@@ -1,80 +0,0 @@
-name: Update Documentation Parity Tracker
-
-on:
-  push:
-    branches: [ "main" ]
-    paths:
-      - 'src/praisonai-agents/praisonaiagents/**/*.py'
-      - 'src/praisonai-ts/src/**/*.ts'
-      - 'src/praisonai-rust/src/**/*.rs'
-      - 'src/praisonai/praisonai/_dev/parity/**/*.py'
-      - '.github/workflows/update-docs-parity.yml'
-  workflow_dispatch:  # Allow manual trigger
-
-permissions:
-  contents: write
-
-jobs:
-  update-docs-parity:
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-      with:
-        ref: main
-        persist-credentials: true
-        fetch-depth: 0
-
-    - name: Checkout PraisonAIDocs
-      uses: actions/checkout@v4
-      with:
-        repository: MervinPraison/PraisonAIDocs
-        path: PraisonAIDocs
-        token: ${{ secrets.DOCS_PAT }}
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-
-    - name: Install dependencies
-      run: |
-        pip install pyyaml
-
-    - name: Generate docs parity trackers
-      run: |
-        cd $GITHUB_WORKSPACE
-        python3 src/praisonai/scripts/generate_docs_parity.py --docs-root PraisonAIDocs/docs --copy-docs
-        
-    - name: Check for changes
-      id: check_changes
-      run: |
-        if git diff --quiet src/praisonai-agents/DOCS_PARITY.md src/praisonai-ts/DOCS_PARITY.md src/praisonai-rust/DOCS_PARITY.md 2>/dev/null; then
-          echo "changes=false" >> $GITHUB_OUTPUT
-          echo "No changes to docs parity trackers"
-        else
-          echo "changes=true" >> $GITHUB_OUTPUT
-          echo "Docs parity trackers have been updated"
-          git diff --stat src/praisonai-agents/DOCS_PARITY.md src/praisonai-ts/DOCS_PARITY.md src/praisonai-rust/DOCS_PARITY.md
-        fi
-
-    - name: Commit and push changes to praisonai-package
-      if: steps.check_changes.outputs.changes == 'true'
-      uses: stefanzweifel/git-auto-commit-action@v5
-      with:
-        commit_message: "docs: auto-update documentation parity trackers [skip ci]"
-        file_pattern: 'src/praisonai-agents/DOCS_PARITY.md src/praisonai-ts/DOCS_PARITY.md src/praisonai-rust/DOCS_PARITY.md'
-        commit_user_name: "github-actions[bot]"
-        commit_user_email: "41898282+github-actions[bot]@users.noreply.github.com"
-        commit_author: "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
-
-    - name: Commit and push changes to PraisonAIDocs
-      if: steps.check_changes.outputs.changes == 'true'
-      run: |
-        cd PraisonAIDocs
-        git config user.name "github-actions[bot]"
-        git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-        git add docs/features/DOCS_PARITY.md docs/js/DOCS_PARITY.md docs/rust/DOCS_PARITY.md
-        git diff --staged --quiet || git commit -m "docs: auto-update documentation parity trackers [skip ci]"
-        git push

.github/workflows/update-parity-tracker.yml

@@ -1,58 +0,0 @@
-name: Update Feature Parity Tracker
-
-on:
-  push:
-    branches: [ "main" ]
-    paths:
-      - 'src/praisonai-agents/praisonaiagents/**/*.py'
-      - 'src/praisonai-ts/src/**/*.ts'
-      - 'src/praisonai-rust/src/**/*.rs'
-      - '.github/workflows/update-parity-tracker.yml'
-
-permissions:
-  contents: write
-
-jobs:
-  update-parity-tracker:
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-      with:
-        ref: main
-        persist-credentials: true
-        fetch-depth: 0
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.11'
-
-    - name: Generate parity trackers
-      run: |
-        cd $GITHUB_WORKSPACE
-        python3 src/praisonai/scripts/generate_parity_tracker.py
-        
-    - name: Check for changes
-      id: check_changes
-      run: |
-        if git diff --quiet src/praisonai-ts/FEATURE_PARITY_TRACKER.json src/praisonai-ts/PARITY.md src/praisonai-rust/FEATURE_PARITY_TRACKER.json src/praisonai-rust/PARITY.md 2>/dev/null; then
-          echo "changes=false" >> $GITHUB_OUTPUT
-          echo "No changes to parity trackers"
-        else
-          echo "changes=true" >> $GITHUB_OUTPUT
-          echo "Parity trackers have been updated"
-          git diff src/praisonai-ts/FEATURE_PARITY_TRACKER.json | head -50
-        fi
-
-    - name: Commit and push changes
-      if: steps.check_changes.outputs.changes == 'true'
-      uses: stefanzweifel/git-auto-commit-action@v5
-      with:
-        commit_message: "docs: auto-update feature parity trackers [skip ci]"
-        file_pattern: 'src/praisonai-ts/FEATURE_PARITY_TRACKER.json src/praisonai-ts/PARITY.md src/praisonai-rust/FEATURE_PARITY_TRACKER.json src/praisonai-rust/PARITY.md'
-        commit_user_name: "github-actions[bot]"
-        commit_user_email: "41898282+github-actions[bot]@users.noreply.github.com"
-        commit_author: "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>"
-

.gitignore

@@ -20,7 +20,6 @@ watch.sh
 docs.sh
 other
 output
-!src/praisonai/praisonai/cli/output/
 
 .files
 threads.db
@@ -76,21 +75,4 @@ agents/praisonaiagents/praisonaiagents.egg-info
 # Local Netlify folder
 .netlify
 .qodo
-CopilotKit*
-.gemini
-issue_details.json
-
-# MCP Registry tokens
-.mcpregistry_*
-
-*.log
-.internal
-.praisonai
-
-# Rust / Cargo
-target/
-Cargo.lock
-**/*.rs.bk
-*.pdb
-.windsurf
-.agent
+CopilotKit*

docker/.env.template

@@ -13,12 +13,6 @@ GOOGLE_API_KEY=your_google_api_key_here
 GROQ_API_KEY=your_groq_api_key_here
 COHERE_API_KEY=your_cohere_api_key_here
 
-# Bot Tokens (for messaging bot services)
-SLACK_BOT_TOKEN=xoxb-your-slack-bot-token
-SLACK_APP_TOKEN=xapp-your-slack-app-token
-DISCORD_BOT_TOKEN=your-discord-bot-token
-TELEGRAM_BOT_TOKEN=your-telegram-bot-token
-
 # Optional: Service Configuration
 FLASK_ENV=development
 CHAINLIT_HOST=0.0.0.0

docker/Dockerfile

@@ -14,10 +14,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN mkdir -p /root/.praison
 
 # Install Python packages (using latest versions)
-# Note: praisonai is installed from PyPI - remove version pin to use latest available
 RUN pip install --no-cache-dir \
     flask \
-    praisonai \
+    "praisonai>=2.2.33" \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

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

docker/Dockerfile.dev

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

docker/Dockerfile.serve

@@ -1,25 +0,0 @@
-# Dockerfile for PraisonAI Serve API
-# Deploy to Railway, Render, Fly.io, or any container platform
-#
-# Build: docker build -f Dockerfile.serve -t praisonai-serve .
-# Run:   docker run -p 8005:8005 -e OPENAI_API_KEY=sk-xxx praisonai-serve
-
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Install dependencies
-RUN pip install --no-cache-dir praisonai praisonaiagents
-
-# Copy agents configuration
-COPY agents.yaml .
-
-# Expose the API port
-EXPOSE 8005
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8005/health || exit 1
-
-# Start the API server
-CMD ["praisonai", "serve", "agents.yaml", "--host", "0.0.0.0", "--port", "8005"]

docker/Dockerfile.ui

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

docker/README.md

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

docker/bots/.env.template

@@ -1,15 +0,0 @@
-# Bot Environment Variables
-# Copy to .env and fill in your values
-
-# Required: LLM API Key
-OPENAI_API_KEY=your_openai_api_key_here
-
-# Slack Bot (Socket Mode)
-SLACK_BOT_TOKEN=xoxb-your-slack-bot-token
-SLACK_APP_TOKEN=xapp-your-slack-app-token
-
-# Discord Bot
-DISCORD_BOT_TOKEN=your-discord-bot-token
-
-# Telegram Bot
-TELEGRAM_BOT_TOKEN=your-telegram-bot-token

docker/bots/Dockerfile

@@ -1,42 +0,0 @@
-# Dockerfile for PraisonAI Slack Bot
-# Secrets are passed at runtime via environment variables
-
-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 \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create praison config directory
-RUN mkdir -p /root/.praison
-
-# Install praisonai with bot dependencies
-RUN pip install --no-cache-dir \
-    praisonai \
-    slack-bolt \
-    slack-sdk \
-    "discord.py>=2.0.0" \
-    "python-telegram-bot>=20.0"
-
-# Set environment variables for directory management
-ENV PRAISON_CONFIG_DIR=/root/.praison
-ENV DOCKER_CONTAINER=true
-
-# Bot tokens should be passed at runtime (not baked into image)
-# SLACK_BOT_TOKEN=xoxb-...
-# SLACK_APP_TOKEN=xapp-...
-
-# Optional: Copy custom agent configuration
-# COPY agent.yaml /app/agent.yaml
-
-# Expose no ports - Socket Mode doesn't need them
-# For webhook mode, expose port 3000
-
-# Default command - tokens from environment
-CMD ["praisonai", "bot", "slack"]

docker/bots/README.md

@@ -1,66 +0,0 @@
-# PraisonAI Bot Docker Deployment
-
-Deploy Slack, Discord, or Telegram bots using Docker.
-
-## Quick Start
-
-```bash
-# 1. Copy environment template
-cp .env.template .env
-
-# 2. Edit .env with your tokens
-nano .env
-
-# 3. Run specific bot
-docker compose up slack-bot -d
-
-# Or run all bots
-docker compose up -d
-```
-
-## Environment Variables
-
-| Variable | Required | Description |
-|----------|----------|-------------|
-| `OPENAI_API_KEY` | Yes | LLM API key |
-| `SLACK_BOT_TOKEN` | For Slack | Bot token (xoxb-...) |
-| `SLACK_APP_TOKEN` | For Slack | App token (xapp-...) |
-| `DISCORD_BOT_TOKEN` | For Discord | Bot token |
-| `TELEGRAM_BOT_TOKEN` | For Telegram | Bot token |
-
-## Slack Setup
-
-1. Create app at https://api.slack.com/apps
-2. Enable **Socket Mode** → Generate App-Level Token with `connections:write`
-3. Add **OAuth Scopes**: `chat:write`, `app_mentions:read`, `im:history`
-4. Enable **Event Subscriptions** → Subscribe to `app_mention`, `message.im`
-5. **Install to Workspace**
-6. Copy Bot Token and App Token to `.env`
-
-## Commands
-
-```bash
-# Start Slack bot
-docker compose up slack-bot -d
-
-# View logs
-docker compose logs -f slack-bot
-
-# Stop bot
-docker compose down slack-bot
-
-# Rebuild after updates
-docker compose build --no-cache slack-bot
-```
-
-## Custom Agent Configuration
-
-Mount your agent config:
-
-```yaml
-services:
-  slack-bot:
-    volumes:
-      - ./agent.yaml:/app/agent.yaml
-    command: ["praisonai", "bot", "slack", "--agent", "/app/agent.yaml"]
-```

docker/bots/docker-compose.yml

@@ -1,53 +0,0 @@
-version: '3.8'
-
-# PraisonAI Bot Services
-# Run specific bots: docker compose up slack-bot
-# Run all bots: docker compose up
-
-services:
-  # Slack Bot
-  slack-bot:
-    build:
-      context: ../..
-      dockerfile: docker/bots/Dockerfile
-    volumes:
-      - praison_data:/root/.praison
-    environment:
-      OPENAI_API_KEY: ${OPENAI_API_KEY}
-      SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
-      SLACK_APP_TOKEN: ${SLACK_APP_TOKEN}
-      PRAISON_CONFIG_DIR: /root/.praison
-    command: [ "praisonai", "bot", "slack" ]
-    restart: unless-stopped
-
-  # Discord Bot
-  discord-bot:
-    build:
-      context: ../..
-      dockerfile: docker/bots/Dockerfile
-    volumes:
-      - praison_data:/root/.praison
-    environment:
-      OPENAI_API_KEY: ${OPENAI_API_KEY}
-      DISCORD_BOT_TOKEN: ${DISCORD_BOT_TOKEN}
-      PRAISON_CONFIG_DIR: /root/.praison
-    command: [ "praisonai", "bot", "discord" ]
-    restart: unless-stopped
-
-  # Telegram Bot
-  telegram-bot:
-    build:
-      context: ../..
-      dockerfile: docker/bots/Dockerfile
-    volumes:
-      - praison_data:/root/.praison
-    environment:
-      OPENAI_API_KEY: ${OPENAI_API_KEY}
-      TELEGRAM_BOT_TOKEN: ${TELEGRAM_BOT_TOKEN}
-      PRAISON_CONFIG_DIR: /root/.praison
-    command: [ "praisonai", "bot", "telegram" ]
-    restart: unless-stopped
-
-volumes:
-  praison_data:
-    driver: local

docker/docker-compose.dev.yml

@@ -137,11 +137,22 @@ services:
       POSTGRES_USER: praisonai
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-praisonai_dev_pass}
     volumes:
+   database:
+     image: postgres:15-alpine
+     environment:
+       POSTGRES_DB: praisonai_dev
+       POSTGRES_USER: praisonai
+       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-praisonai_dev_pass}
+     volumes:
+       - postgres_data:/var/lib/postgresql/data
+     read_only: true
+     tmpfs:
+       - /tmp
+       - /var/tmp
+     ports:
+       - "5432:5432"
+     networks:
       - postgres_data:/var/lib/postgresql/data
-    read_only: true
-    tmpfs:
-      - /tmp
-      - /var/tmp
     ports:
       - "5432:5432"
     networks:

docker/docker-compose.yml

@@ -22,7 +22,7 @@ services:
       CHAINLIT_DB_DIR: /root/.praison
     command: praisonai ui --host 0.0.0.0
     healthcheck:
-      test: [ "CMD", "curl", "-f", "http://localhost:8082" ]
+      test: ["CMD", "curl", "-f", "http://localhost:8082"]
       interval: 10s
       timeout: 5s
       retries: 3
@@ -49,7 +49,7 @@ services:
       CHAINLIT_DB_DIR: /root/.praison
     command: praisonai chat --host 0.0.0.0 --port 8083
     healthcheck:
-      test: [ "CMD", "curl", "-f", "http://localhost:8083" ]
+      test: ["CMD", "curl", "-f", "http://localhost:8083"]
       interval: 10s
       timeout: 5s
       retries: 3
@@ -69,7 +69,7 @@ services:
       OPENAI_API_KEY: ${OPENAI_API_KEY}
       PRAISON_CONFIG_DIR: /root/.praison
     healthcheck:
-      test: [ "CMD", "curl", "-f", "http://localhost:8080/health" ]
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
       interval: 10s
       timeout: 5s
       retries: 3
@@ -89,7 +89,6 @@ services:
       PRAISON_CONFIG_DIR: /root/.praison
     networks:
       - praison_network
-  # For bot services (Slack, Discord, Telegram), see docker/bots/
 
 volumes:
   praison_data:
@@ -97,4 +96,4 @@ volumes:
 
 networks:
   praison_network:
-    driver: bridge
+    driver: bridge

examples/README.md

@@ -1,83 +0,0 @@
-# PraisonAI Examples
-
-This folder contains examples for PraisonAI. For detailed documentation, visit [docs.praison.ai](https://docs.praison.ai).
-
-## Structure
-
-```
-examples/
-├── python/           # Python examples
-│   ├── agents/       # Agent examples (single, multi, router, etc.)
-│   ├── workflows/    # Workflow patterns (routing, parallel, loop)
-│   ├── tools/        # Custom tools examples
-│   ├── mcp/          # MCP protocol examples
-│   ├── memory/       # Memory and sessions
-│   ├── code/         # Code editing and external CLI tools
-│   └── ...
-├── serve/            # Server and endpoints examples
-├── yaml/             # YAML workflow examples
-└── cookbooks/        # Complete use-case examples
-```
-
-## Quick Links
-
-| Category | Examples | Docs |
-|----------|----------|------|
-| **Consolidated Params** | [consolidated_params/](consolidated_params/) | [📖](https://docs.praison.ai/api/consolidated-params) |
-| **Agents** | [python/agents/](python/agents/) | [📖](https://docs.praison.ai/concepts/agents) |
-| **Workflows** | [python/workflows/](python/workflows/) | [📖](https://docs.praison.ai/features/workflows) |
-| **Model Router** | [python/agents/router-agent-cost-optimization.py](python/agents/router-agent-cost-optimization.py) | [📖](https://docs.praison.ai/features/model-router) |
-| **MCP** | [python/mcp/](python/mcp/) | [📖](https://docs.praison.ai/mcp) |
-| **Memory** | [python/memory/](python/memory/) | [📖](https://docs.praison.ai/concepts/memory) |
-| **Tools** | [python/tools/](python/tools/) | [📖](https://docs.praison.ai/tools) |
-| **Code** | [python/code/](python/code/) | [📖](https://docs.praison.ai/code) |
-| **YAML** | [yaml/](yaml/) | [📖](https://docs.praison.ai/features/yaml-workflows) |
-| **Doctor** | [doctor/](doctor/) | [📖](https://docs.praison.ai/cli/doctor) |
-| **Serve** | [serve/](serve/) | [📖](https://docs.praison.ai/cli/serve) |
-| **Endpoints** | [serve/](serve/) | [📖](https://docs.praison.ai/cli/endpoints) |
-
-## Consolidated Params Examples
-
-Agent-centric API with unified parameter resolution. Precedence: Instance > Config > Array > Dict > String > Bool > Default
-
-| Example | Description |
-|---------|-------------|
-| [basic_agent.py](consolidated_params/basic_agent.py) | Minimal agent with memory |
-| [basic_agents.py](consolidated_params/basic_agents.py) | Multi-agent with memory+planning |
-| [basic_workflow.py](consolidated_params/basic_workflow.py) | Workflow with consolidated params |
-| [basic_memory.py](consolidated_params/basic_memory.py) | Memory presets (file, redis, postgres) |
-| [basic_guardrails.py](consolidated_params/basic_guardrails.py) | Guardrails with callable or config |
-| [basic_workflow_agentlike.py](consolidated_params/basic_workflow_agentlike.py) | Workflow with agent-like params |
-| [basic_step_override.py](consolidated_params/basic_step_override.py) | Step-level override of workflow defaults |
-| [advanced_workflow_full_features.py](consolidated_params/advanced_workflow_full_features.py) | All consolidated params |
-
-## Serve Examples
-
-| Example | Description | CLI Command |
-|---------|-------------|-------------|
-| [unified_server.py](serve/unified_server.py) | All providers in one server | `praisonai serve unified` |
-| [agent_as_api_single.py](serve/agent_as_api_single.py) | Single agent HTTP API | `praisonai serve agents` |
-| [agents_as_api_router.py](serve/agents_as_api_router.py) | Multi-agent router API | `praisonai serve agents` |
-| [a2a_server_client.py](serve/a2a_server_client.py) | A2A protocol server | `praisonai serve a2a` |
-| [a2u_events_stream.py](serve/a2u_events_stream.py) | A2U event stream | `praisonai serve a2u` |
-| [mcp_http_server.py](serve/mcp_http_server.py) | MCP HTTP server | `praisonai serve mcp` |
-| [tools_as_mcp_server.py](serve/tools_as_mcp_server.py) | Tools as MCP server | `praisonai serve tools` |
-| [agent_launch_modes.py](serve/agent_launch_modes.py) | Agent.launch() API | Python only |
-| [endpoints_unified_client.py](serve/endpoints_unified_client.py) | Unified client | `praisonai endpoints` |
-
-## Running Examples
-
-```bash
-# Install PraisonAI
-pip install praisonai
-
-# Set API key
-export OPENAI_API_KEY=your_key_here
-
-# Run an example
-python examples/python/agents/single-agent.py
-```
-
-## CLI Commands
-
-See the main [README.md](../README.md#-cli--no-code-interface) for all CLI commands.

examples/acp/README.md

@@ -1,137 +0,0 @@
-# ACP (Agent Client Protocol) Examples
-
-This directory contains examples for using PraisonAI with the Agent Client Protocol (ACP).
-
-## What is ACP?
-
-The Agent Client Protocol (ACP) is a standardized JSON-RPC 2.0 protocol that allows code editors and IDEs to communicate with AI coding agents. It enables seamless integration between PraisonAI and editors like:
-
-- **Zed**
-- **JetBrains IDEs** (IntelliJ, PyCharm, WebStorm, etc.)
-- **VSCode** (via extensions)
-- **Toad**
-
-## Quick Start
-
-### CLI Usage
-
-```bash
-# Start ACP server with defaults
-praisonai acp
-
-# Enable debug logging
-praisonai acp --debug
-
-# Allow file writes
-praisonai acp --allow-write
-
-# Use a specific model
-praisonai acp -m gpt-4o
-
-# Resume last session
-praisonai acp --resume --last
-```
-
-### Python API
-
-```python
-from praisonai.acp import serve
-
-serve(
-    workspace=".",
-    debug=True,
-    allow_write=True,
-)
-```
-
-## Editor Configuration
-
-### Zed
-
-Add to `~/.config/zed/settings.json`:
-
-```json
-{
-  "agent_servers": {
-    "PraisonAI": {
-      "command": "praisonai",
-      "args": ["acp"],
-      "env": {}
-    }
-  }
-}
-```
-
-### JetBrains
-
-Add to `~/.jetbrains/acp.json`:
-
-```json
-{
-  "agent_servers": {
-    "PraisonAI": {
-      "command": "praisonai",
-      "args": ["acp"],
-      "env": {}
-    }
-  }
-}
-```
-
-### Toad
-
-```bash
-toad acp "praisonai acp"
-```
-
-## Examples
-
-- `basic_acp_server.py` - Simple ACP server with default settings
-- `custom_agent_acp.py` - ACP server with a custom agent
-
-## CLI Options
-
-| Option | Description |
-|--------|-------------|
-| `-w, --workspace` | Workspace root directory |
-| `-a, --agent` | Agent name or config file |
-| `-m, --model` | LLM model to use |
-| `-r, --resume` | Resume session by ID |
-| `--last` | Resume the last session |
-| `--approve` | Approval mode: manual, auto, scoped |
-| `--read-only` | Read-only mode (default) |
-| `--allow-write` | Allow file writes |
-| `--allow-shell` | Allow shell commands |
-| `--debug` | Enable debug logging |
-
-## Installation
-
-```bash
-pip install praisonai[acp]
-```
-
-## Protocol Details
-
-ACP uses JSON-RPC 2.0 over stdio:
-- **stdin**: Receives JSON-RPC requests from the client
-- **stdout**: Sends JSON-RPC responses to the client
-- **stderr**: Debug/log output (never pollutes stdout)
-
-### Supported Methods
-
-**Agent Methods (client → agent):**
-- `initialize` - Negotiate protocol version and capabilities
-- `authenticate` - Optional authentication
-- `session/new` - Create a new session
-- `session/load` - Load an existing session
-- `session/prompt` - Send user message
-- `session/cancel` - Cancel ongoing operations
-- `session/set_mode` - Change operating mode
-
-**Client Methods (agent → client):**
-- `session/update` - Send progress updates
-- `session/request_permission` - Request user approval
-- `fs/read_text_file` - Read file contents
-- `fs/write_text_file` - Write file contents
-- `terminal/create` - Create terminal
-- `terminal/output` - Get terminal output

examples/acp/basic_acp_server.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python3
-"""
-Basic ACP Server Example
-
-This example demonstrates how to run PraisonAI as an ACP server
-that can be connected to by IDEs like Zed, JetBrains, VSCode, or Toad.
-
-Usage:
-    # Run from command line
-    praisonai acp
-    
-    # Or run this script directly
-    python basic_acp_server.py
-"""
-
-from praisonai.acp import serve
-
-if __name__ == "__main__":
-    # Start ACP server with default settings
-    # This will listen on stdin/stdout for JSON-RPC messages
-    serve(
-        workspace=".",           # Current directory as workspace
-        agent="default",         # Use default agent
-        debug=False,             # Set to True for debug logging to stderr
-        read_only=True,          # Safe by default
-        approval_mode="manual",  # Require approval for actions
-    )

examples/acp/custom_agent_acp.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-"""
-Custom Agent ACP Server Example
-
-This example shows how to run a custom PraisonAI agent as an ACP server.
-
-Usage:
-    python custom_agent_acp.py
-"""
-
-from praisonai.acp import serve, ACPServer, ACPConfig
-from praisonaiagents import Agent
-
-# Create a custom agent
-agent = Agent(
-    name="CodeAssistant",
-    instructions="""You are an expert coding assistant. You help users:
-    - Write clean, efficient code
-    - Debug issues
-    - Explain complex concepts
-    - Review code for best practices
-    
-    Always provide clear explanations with your code suggestions.""",
-    model="gpt-4o-mini",
-)
-
-if __name__ == "__main__":
-    # Create config
-    config = ACPConfig(
-        workspace=".",
-        debug=True,
-        allow_write=True,  # Allow file modifications
-        approval_mode="manual",
-    )
-    
-    # Create server with custom agent
-    server = ACPServer(config=config, agent=agent)
-    
-    # Run the server
-    serve(
-        workspace=".",
-        debug=True,
-        allow_write=True,
-        approval_mode="manual",
-    )

examples/ag2/ag2_basic.yaml

@@ -0,0 +1,30 @@
+framework: ag2
+topic: "Research the latest developments in AI agents"
+
+# Install: pip install "praisonai[ag2]"
+# Run:     praisonai --framework ag2 examples/ag2/ag2_basic.yaml
+#       or praisonai run examples/ag2/ag2_basic.yaml --framework ag2
+
+roles:
+  research_agent:
+    role: "AI Research Specialist"
+    goal: "Research and summarise the latest developments in AI agent frameworks"
+    backstory: |
+      You are an experienced AI researcher with deep knowledge of multi-agent
+      systems, large language models, and the latest trends in AI tooling.
+      You excel at synthesising complex technical topics into clear summaries.
+    tasks:
+      research_task:
+        description: |
+          Research and summarise the latest developments in AI agent frameworks
+          for the topic: {topic}
+
+          Focus on:
+          1. Key frameworks and their unique capabilities
+          2. Recent innovations and improvements
+          3. Community adoption and ecosystem growth
+          4. Practical use cases and success stories
+        expected_output: |
+          A concise research summary covering the key developments,
+          major frameworks, and practical insights. Include 3-5 bullet
+          points of the most important findings.

examples/ag2/ag2_bedrock.yaml

@@ -0,0 +1,42 @@
+framework: ag2
+topic: "Cloud-native AI deployment strategies on AWS"
+
+# AG2 exclusive feature: native AWS Bedrock support via LLMConfig(api_type="bedrock")
+#
+# Prerequisites:
+#   pip install "praisonai[ag2]"
+#   aws configure  (or set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION)
+#
+# Run:
+#   praisonai --framework ag2 examples/ag2/ag2_bedrock.yaml
+#
+# The AG2 adapter detects api_type="bedrock" from the llm config and uses
+# LLMConfig(api_type="bedrock", model=...) — no OPENAI_API_KEY required.
+# AWS credentials are sourced from boto3 (env vars, ~/.aws/credentials, IAM role).
+
+roles:
+  cloud_architect:
+    role: "AWS Cloud Architect"
+    goal: "Design and explain cloud-native AI deployment strategies on AWS"
+    backstory: |
+      You are an AWS Solutions Architect specialising in AI/ML workloads.
+      You have deep expertise in Amazon Bedrock, SageMaker, ECS, and Lambda,
+      and you help organisations deploy AI agents at scale securely and cost-effectively.
+    llm:
+      model: "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"
+      api_type: "bedrock"
+      aws_region: "us-east-1"
+    tasks:
+      architecture_task:
+        description: |
+          Design a cloud-native deployment strategy for AI agents on AWS for: {topic}
+
+          Cover:
+          1. Recommended AWS services (Bedrock, ECS, Lambda, etc.)
+          2. Scalability and cost optimisation patterns
+          3. Security and compliance considerations
+          4. A simple reference architecture overview
+        expected_output: |
+          A concise architecture guide with service recommendations,
+          a high-level deployment diagram description, and key
+          best practices for production AI agent deployments on AWS.

examples/ag2/ag2_multi_agent.yaml

@@ -0,0 +1,54 @@
+framework: ag2
+topic: "The impact of open-source AI on enterprise software development"
+
+# Install: pip install "praisonai[ag2]"
+# Run:     praisonai --framework ag2 examples/ag2/ag2_multi_agent.yaml
+#       or praisonai run examples/ag2/ag2_multi_agent.yaml --framework ag2
+#
+# This example demonstrates AG2's GroupChat multi-agent coordination.
+# Both agents participate in a collaborative conversation managed by
+# a GroupChatManager until the task is complete.
+
+roles:
+  researcher:
+    role: "Research Specialist"
+    goal: "Gather and analyse information on the given topic"
+    backstory: |
+      You are a meticulous researcher who excels at finding relevant
+      information, analysing trends, and presenting data-backed insights.
+      You always cite your reasoning and structure your findings clearly.
+    tasks:
+      research_task:
+        description: |
+          Research the topic: {topic}
+
+          Investigate:
+          1. Current state and adoption rates
+          2. Key players and projects driving the trend
+          3. Technical advantages and challenges
+          4. Business impact and cost implications
+        expected_output: |
+          A structured research briefing with findings on the topic,
+          including key data points, trends, and technical observations.
+
+  writer:
+    role: "Technical Content Writer"
+    goal: "Transform research findings into clear, engaging written content"
+    backstory: |
+      You are a skilled technical writer who turns complex research into
+      accessible, well-structured articles. You focus on clarity, logical
+      flow, and actionable takeaways for a professional audience.
+    tasks:
+      writing_task:
+        description: |
+          Using the research findings provided by the Research Specialist,
+          write a concise article on: {topic}
+
+          The article should:
+          1. Open with a compelling hook
+          2. Present key findings logically
+          3. Include practical implications for developers
+          4. Close with a forward-looking conclusion
+        expected_output: |
+          A 400-500 word article suitable for a technical blog,
+          with clear sections, professional tone, and concrete takeaways.

examples/agent_centric_api.py

@@ -1,244 +0,0 @@
-"""
-Agent-Centric API Example
-
-Demonstrates the consolidated feature parameters for PraisonAI Agents.
-These params provide a cleaner, more intuitive API with progressive disclosure.
-
-Precedence Rule: Instance > Config > Array > String > Bool > Default
-
-Consolidated Params Support:
-- memory: bool | str URL | str preset | [preset, overrides] | MemoryConfig | Instance
-- knowledge: bool | str path | [sources...] | KnowledgeConfig | Instance
-- planning: bool | str LLM | [preset, overrides] | PlanningConfig
-- reflection: bool | str preset | [preset, overrides] | ReflectionConfig
-- guardrails: bool | callable | str prompt | GuardrailConfig
-- web: bool | str provider | [provider, overrides] | WebConfig
-- output: str preset | [preset, overrides] | OutputConfig
-- execution: str preset | [preset, overrides] | ExecutionConfig
-"""
-
-from praisonaiagents import (
-    Agent,
-    # Config classes for progressive disclosure
-    MemoryConfig,
-    KnowledgeConfig,
-    PlanningConfig,
-    ReflectionConfig,
-    GuardrailConfig,
-    WebConfig,
-)
-
-
-def example_simple_enable():
-    """Example 1: Simple boolean enable (easiest)"""
-    print("\n=== Example 1: Simple Boolean Enable ===")
-    
-    agent = Agent(
-        instructions="You are a helpful assistant",
-        memory=True,      # Enable memory with defaults
-        reflection=True,  # Enable self-reflection
-        web=True,         # Enable web search + fetch
-    )
-    print(f"Agent created with memory={agent._memory_instance is not None}")
-    print(f"  self_reflect={agent.self_reflect}")
-    print(f"  web_search={agent.web_search}")
-
-
-def example_with_config():
-    """Example 2: Using config objects (more control)"""
-    print("\n=== Example 2: Using Config Objects ===")
-    
-    agent = Agent(
-        instructions="You are a research assistant",
-        memory=MemoryConfig(
-            backend="file",
-            user_id="researcher_001",
-            auto_memory=True,
-        ),
-        reflection=ReflectionConfig(
-            min_iterations=1,
-            max_iterations=5,
-            llm="gpt-4o-mini",
-        ),
-        web=WebConfig(
-            search=True,
-            fetch=False,  # Only search, no full page fetch
-            max_results=3,
-        ),
-    )
-    print(f"Agent created with user_id={agent.user_id}")
-    print(f"  {agent.max_reflect}")
-    print(f"  web_search={agent.web_search}, web_fetch={agent.web_fetch}")
-
-
-def example_guardrails():
-    """Example 3: Guardrails with callable or config"""
-    print("\n=== Example 3: Guardrails ===")
-    
-    # Option A: Direct callable
-    def my_validator(output):
-        """Simple validator that checks response length."""
-        is_valid = len(output.raw) < 1000
-        return (is_valid, output if is_valid else "Response too long")
-    
-    agent_a = Agent(
-        instructions="Be concise",
-        guardrails=my_validator,  # Direct callable
-    )
-    print(f"Agent A: guardrail is callable = {callable(agent_a.guardrail)}")
-    
-    # Option B: Using GuardrailConfig
-    agent_b = Agent(
-        instructions="Be helpful and safe",
-        guardrails=GuardrailConfig(
-            llm_validator="Ensure the response is helpful, accurate, and safe",
-            max_retries=3,
-        ),
-    )
-    print(f"Agent B: guardrail = {agent_b.guardrail}")
-    print(f"  max_retries = {agent_b.max_guardrail_retries}")
-
-
-def example_planning():
-    """Example 4: Planning mode"""
-    print("\n=== Example 4: Planning Mode ===")
-    
-    agent = Agent(
-        instructions="You are a project planner",
-        planning=PlanningConfig(
-            reasoning=True,
-            read_only=True,  # Plan mode - only read operations
-        ),
-    )
-    print(f"Agent created with planning={agent.planning}")
-    print(f"  plan_mode={agent.plan_mode}")
-    print(f"  planning_reasoning={agent.planning_reasoning}")
-
-
-def example_backward_compatible():
-    """Example 5: Using new consolidated params"""
-    print("\n=== Example 5: Consolidated Params ===")
-    
-    # New consolidated params
-    agent = Agent(
-        instructions="Test agent",
-        reflection=True,
-        web=WebConfig(search=True, fetch=False),
-    )
-    print(f"Consolidated params work: self_reflect={agent.self_reflect}")
-    print(f"  web_search={agent.web_search}, web_fetch={agent.web_fetch}")
-
-
-def example_real_chat():
-    """Example 6: Real chat with new API"""
-    print("\n=== Example 6: Real Chat ===")
-    
-    agent = Agent(
-        instructions="You are a helpful math tutor. Be concise.",
-        reflection=False,
-        web=False,
-    )
-    
-    response = agent.start("What is the square root of 144?")
-    print(f"Response: {response}")
-
-
-def example_string_presets():
-    """Example 7: String presets (NEW - user-friendly shortcuts)"""
-    print("\n=== Example 7: String Presets ===")
-    
-    # Output presets: minimal, normal, verbose, debug, silent
-    agent = Agent(
-        instructions="You are a verbose assistant",
-        output="verbose",      # String preset for output
-        execution="fast",      # String preset for execution
-        web="tavily",          # String preset for web provider
-    )
-    print(f"Output preset 'verbose': verbose={agent.verbose}, metrics={agent.metrics}")
-    print(f"Execution preset 'fast': max_iter={agent.max_iter}")
-    print(f"Web preset 'tavily': web_search={agent.web_search}")
-
-
-def example_array_overrides():
-    """Example 8: Array with overrides (NEW - preset + customization)"""
-    print("\n=== Example 8: Array Overrides ===")
-    
-    # Array format: [preset, {overrides}]
-    agent = Agent(
-        instructions="You are a streaming assistant",
-        output=["verbose", {"stream": True}],      # Verbose preset + enable streaming
-        execution=["fast", {"max_iter": 15}],      # Fast preset + custom max_iter
-    )
-    print(f"Output array override: verbose={agent.verbose}, stream={agent.stream}")
-    print(f"Execution array override: max_iter={agent.max_iter}")
-
-
-def example_url_parsing():
-    """Example 9: URL parsing for memory (NEW - connection strings)"""
-    print("\n=== Example 9: URL Parsing ===")
-    
-    # Memory supports URL connection strings
-    # Supported: postgresql://, redis://, sqlite:///, mongodb://
-    agent = Agent(
-        instructions="You are a database-backed assistant",
-        memory="postgresql://postgres:password@localhost:5432/praisonai",
-    )
-    print("Memory URL parsed: memory enabled")
-    
-    # Also works with presets
-    agent2 = Agent(
-        instructions="You are a redis-backed assistant",
-        memory="redis",  # Preset name
-    )
-    print("Memory preset 'redis': configured")
-
-
-def example_knowledge_sources():
-    """Example 10: Knowledge with sources (list and string)"""
-    print("\n=== Example 10: Knowledge Sources ===")
-    
-    # Single path string
-    agent1 = Agent(
-        instructions="You are a document assistant",
-        knowledge="docs/",  # Single path
-    )
-    print(f"Knowledge single path: knowledge={agent1.knowledge}")
-    
-    # List of sources
-    agent2 = Agent(
-        instructions="You are a multi-source assistant",
-        knowledge=["docs/", "data.pdf", "https://example.com/api"],
-    )
-    print(f"Knowledge list: knowledge={agent2.knowledge}")
-    
-    # With config for advanced settings
-    agent3 = Agent(
-        instructions="You are an advanced RAG assistant",
-        knowledge=KnowledgeConfig(
-            sources=["docs/"],
-            retrieval_k=10,
-            rerank=True,
-        ),
-    )
-    print("Knowledge config: configured with rerank")
-
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("PraisonAI Agent-Centric API Examples")
-    print("=" * 60)
-    
-    example_simple_enable()
-    example_with_config()
-    example_guardrails()
-    example_planning()
-    example_backward_compatible()
-    example_real_chat()
-    example_string_presets()
-    example_array_overrides()
-    example_url_parsing()
-    example_knowledge_sources()
-    
-    print("\n" + "=" * 60)
-    print("All examples completed!")
-    print("=" * 60)

examples/agent_tools/agent_centric_example.py

@@ -1,135 +0,0 @@
-"""
-Agent-Centric Tools Example
-
-This example demonstrates how to use LSP/ACP-powered tools that make
-the Agent the central orchestrator for file operations.
-
-How to run:
-    export OPENAI_API_KEY=your_key
-    python examples/agent_tools/agent_centric_example.py
-
-Prerequisites:
-    pip install praisonai praisonaiagents
-"""
-
-import asyncio
-import os
-import sys
-import tempfile
-import shutil
-
-# Add paths for development
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../src/praisonai'))
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../src/praisonai-agents'))
-
-
-async def main():
-    print("=" * 60)
-    print("AGENT-CENTRIC TOOLS EXAMPLE")
-    print("=" * 60)
-    print()
-    
-    # Create temporary workspace
-    workspace = tempfile.mkdtemp(prefix="praisonai_example_")
-    print(f"Workspace: {workspace}")
-    print()
-    
-    try:
-        # Import after path setup
-        from praisonai.cli.features import (
-            create_agent_centric_tools,
-            InteractiveRuntime,
-            RuntimeConfig
-        )
-        from praisonaiagents import Agent
-        
-        # 1. Create runtime with ACP enabled
-        print("1. Creating InteractiveRuntime with ACP...")
-        config = RuntimeConfig(
-            workspace=workspace,
-            lsp_enabled=False,  # Skip LSP for this example
-            acp_enabled=True,
-            approval_mode="auto"  # Auto-approve for demo
-        )
-        runtime = InteractiveRuntime(config)
-        status = await runtime.start()
-        
-        print(f"   ACP ready: {runtime.acp_ready}")
-        print(f"   Read-only: {runtime.read_only}")
-        print()
-        
-        # 2. Create agent-centric tools
-        print("2. Creating agent-centric tools...")
-        tools = create_agent_centric_tools(runtime)
-        print(f"   Tools created: {len(tools)}")
-        for tool in tools:
-            print(f"     - {tool.__name__}")
-        print()
-        
-        # 3. Create Agent with ACP-powered tools
-        print("3. Creating Agent with ACP-powered tools...")
-        agent = Agent(
-            name="FileAgent",
-            instructions="""You help create and manage files. 
-            Use acp_create_file to create files.
-            Use read_file to read files.
-            Use list_files to list directory contents.""",
-            tools=tools,
-            output="verbose"  # Use new consolidated param
-        )
-        print()
-        
-        # 4. Ask agent to create a file
-        print("4. Asking agent to create a Python file...")
-        print("-" * 40)
-        result = agent.start(
-            "Create a Python file called calculator.py with add and subtract functions"
-        )
-        print("-" * 40)
-        print(f"Agent response: {result[:200]}..." if len(str(result)) > 200 else f"Agent response: {result}")
-        print()
-        
-        # 5. Verify file was created
-        print("5. Verifying file creation...")
-        calc_path = os.path.join(workspace, "calculator.py")
-        if os.path.exists(calc_path):
-            print(f"   ✓ File created at {calc_path}")
-            with open(calc_path) as f:
-                content = f.read()
-                print(f"   Content preview:")
-                for line in content.split('\n')[:10]:
-                    print(f"     {line}")
-        else:
-            # Check what files exist
-            files = os.listdir(workspace)
-            print(f"   Files in workspace: {files}")
-            for f in files:
-                fp = os.path.join(workspace, f)
-                if os.path.isfile(fp):
-                    print(f"   ✓ Found: {f}")
-        print()
-        
-        # 6. Ask agent to read the file
-        print("6. Asking agent to read the file...")
-        print("-" * 40)
-        result2 = agent.start("Read the calculator.py file and tell me what functions it has")
-        print("-" * 40)
-        print(f"Agent response: {result2[:300]}..." if len(str(result2)) > 300 else f"Agent response: {result2}")
-        print()
-        
-        # Cleanup
-        await runtime.stop()
-        
-    finally:
-        # Clean up workspace
-        shutil.rmtree(workspace, ignore_errors=True)
-        print(f"Cleaned up workspace: {workspace}")
-    
-    print()
-    print("=" * 60)
-    print("EXAMPLE COMPLETE")
-    print("=" * 60)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

examples/approval/README.md

@@ -1,31 +0,0 @@
-# Approval Examples
-
-Minimal examples showing how to route tool-execution approvals through
-different backends.
-
-## Quick Start
-
-```bash
-pip install praisonaiagents praisonai[bot]
-export OPENAI_API_KEY=sk-...
-```
-
-| Backend  | Script               | Extra env vars                                   |
-|----------|-----------------------|--------------------------------------------------|
-| Slack    | `slack_approval.py`   | `SLACK_BOT_TOKEN`, `SLACK_CHANNEL`               |
-| Telegram | `telegram_approval.py`| `TELEGRAM_BOT_TOKEN`, `TELEGRAM_CHAT_ID`         |
-| Discord  | `discord_approval.py` | `DISCORD_BOT_TOKEN`, `DISCORD_CHANNEL_ID`        |
-| HTTP     | `http_approval.py`    | *(none — opens a local web dashboard)*           |
-| Agent    | `agent_approval.py`   | *(none — AI reviewer agent decides)*             |
-
-## SSL Verification
-
-For corporate proxy / CA issues, Discord and Telegram backends support
-optional SSL bypass:
-
-```bash
-export PRAISONAI_DISCORD_SSL_VERIFY=false
-export PRAISONAI_TELEGRAM_SSL_VERIFY=false
-```
-
-Default is `true` (secure).

examples/approval/agent_approval.py

@@ -1,26 +0,0 @@
-"""
-Agent Approval Example
-======================
-Uses an AI agent as an automated reviewer to approve/deny tool calls.
-
-Requires:
-    pip install praisonaiagents
-    export OPENAI_API_KEY=sk-...
-"""
-
-from praisonaiagents import Agent
-from praisonaiagents.approval import AgentApproval
-from praisonaiagents.tools.shell_tools import execute_command
-
-reviewer = AgentApproval(
-    instructions="Only approve read-only commands like 'ls' or 'cat'. Deny destructive commands.",
-)
-
-agent = Agent(
-    name="DevOps",
-    instructions="You are a DevOps assistant. Use shell tools when asked.",
-    tools=[execute_command],
-    approval=reviewer,
-)
-
-agent.start("List files in the current directory")

examples/approval/discord_approval.py

@@ -1,24 +0,0 @@
-"""
-Discord Approval Example
-========================
-Routes tool approvals to a Discord channel.
-
-Requires:
-    pip install praisonaiagents praisonai[bot]
-    export DISCORD_BOT_TOKEN=MTIz...
-    export DISCORD_CHANNEL_ID=1234567890
-    export OPENAI_API_KEY=sk-...
-"""
-
-from praisonaiagents import Agent
-from praisonaiagents.tools.shell_tools import execute_command
-from praisonai.bots import DiscordApproval
-
-agent = Agent(
-    name="DevOps",
-    instructions="You are a DevOps assistant. Use shell tools when asked.",
-    tools=[execute_command],
-    approval=DiscordApproval(),
-)
-
-agent.start("List files in the current directory")

examples/approval/http_approval.py

@@ -1,22 +0,0 @@
-"""
-HTTP Approval Example
-=====================
-Opens a local web dashboard for tool approvals.
-
-Requires:
-    pip install praisonaiagents praisonai[bot]
-    export OPENAI_API_KEY=sk-...
-"""
-
-from praisonaiagents import Agent
-from praisonaiagents.tools.shell_tools import execute_command
-from praisonai.bots import HTTPApproval
-
-agent = Agent(
-    name="DevOps",
-    instructions="You are a DevOps assistant. Use shell tools when asked.",
-    tools=[execute_command],
-    approval=HTTPApproval(),
-)
-
-agent.start("List files in the current directory")

examples/approval/slack_approval.py

@@ -1,24 +0,0 @@
-"""
-Slack Approval Example
-======================
-Routes tool approvals to a Slack channel.
-
-Requires:
-    pip install praisonaiagents praisonai[bot]
-    export SLACK_BOT_TOKEN=xoxb-...
-    export SLACK_CHANNEL=C0123456789
-    export OPENAI_API_KEY=sk-...
-"""
-
-from praisonaiagents import Agent
-from praisonaiagents.tools.shell_tools import execute_command
-from praisonai.bots import SlackApproval
-
-agent = Agent(
-    name="DevOps",
-    instructions="You are a DevOps assistant. Use shell tools when asked.",
-    tools=[execute_command],
-    approval=SlackApproval(),
-)
-
-agent.start("List files in the current directory")

examples/approval/telegram_approval.py

@@ -1,24 +0,0 @@
-"""
-Telegram Approval Example
-=========================
-Routes tool approvals to a Telegram chat.
-
-Requires:
-    pip install praisonaiagents praisonai[bot]
-    export TELEGRAM_BOT_TOKEN=123456:ABC-...
-    export TELEGRAM_CHAT_ID=987654321
-    export OPENAI_API_KEY=sk-...
-"""
-
-from praisonaiagents import Agent
-from praisonaiagents.tools.shell_tools import execute_command
-from praisonai.bots import TelegramApproval
-
-agent = Agent(
-    name="DevOps",
-    instructions="You are a DevOps assistant. Use shell tools when asked.",
-    tools=[execute_command],
-    approval=TelegramApproval(),
-)
-
-agent.start("List files in the current directory")

examples/async_runs/README.py

@@ -1,35 +0,0 @@
-"""
-Async Runs Examples
-===================
-
-This directory contains examples for the PraisonAI Async Jobs API.
-
-Examples:
----------
-1. sdk_submit_poll_result.py - Python SDK example for submit/poll/result
-2. cli_submit_poll_result.sh - Bash/curl example for submit/poll/result
-3. idempotency.sh - Demonstrates idempotency key usage
-4. cancel.sh - Demonstrates job cancellation
-5. sse_stream.sh - Demonstrates SSE streaming
-
-Prerequisites:
---------------
-1. Set OPENAI_API_KEY environment variable
-2. Start the jobs server:
-   
-   cd /path/to/praisonai-package/src/praisonai
-   python -m uvicorn praisonai.jobs.server:create_app --port 8005 --factory
-
-3. Run examples:
-   
-   python sdk_submit_poll_result.py
-   bash cli_submit_poll_result.sh
-   bash idempotency.sh
-   bash cancel.sh
-   bash sse_stream.sh
-
-Environment Variables:
-----------------------
-- OPENAI_API_KEY: Required for agent execution
-- PRAISONAI_BASE_URL: API server URL (default: http://127.0.0.1:8005)
-"""

examples/async_runs/cancel.sh

@@ -1,54 +0,0 @@
-#!/bin/bash
-# CLI Example: Cancel a Running Job
-#
-# This example demonstrates how to cancel a running job.
-#
-# Requirements:
-# - Jobs server running on http://127.0.0.1:8005
-#
-# Usage:
-#     bash cancel.sh
-
-set -e
-
-API_URL="${PRAISONAI_BASE_URL:-http://127.0.0.1:8005}"
-
-echo "============================================================"
-echo "PraisonAI Job Cancellation Example"
-echo "============================================================"
-
-# Submit a long-running job
-echo ""
-echo "1. Submitting a job..."
-RESPONSE=$(curl -s -X POST "$API_URL/api/v1/runs" \
-    -H "Content-Type: application/json" \
-    -d '{"prompt": "Write a detailed essay about the history of computing."}')
-
-JOB_ID=$(echo "$RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin)['job_id'])")
-echo "   Job ID: $JOB_ID"
-
-# Wait briefly
-echo ""
-echo "2. Waiting 1 second..."
-sleep 1
-
-# Cancel the job
-echo ""
-echo "3. Cancelling job..."
-CANCEL_RESPONSE=$(curl -s -X POST "$API_URL/api/v1/runs/$JOB_ID/cancel")
-STATUS=$(echo "$CANCEL_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin)['status'])")
-echo "   Status after cancel: $STATUS"
-
-# Verify cancellation
-echo ""
-echo "4. Verification:"
-if [ "$STATUS" = "cancelled" ]; then
-    echo "   ✓ SUCCESS: Job was cancelled"
-else
-    echo "   ℹ Job status: $STATUS (may have completed before cancel)"
-fi
-
-echo ""
-echo "============================================================"
-echo "Cancellation example completed!"
-echo "============================================================"

examples/async_runs/cli_submit_poll_result.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-# CLI Example: Submit, Poll, and Get Result for Async Jobs
-#
-# This example demonstrates how to use the PraisonAI CLI to:
-# 1. Submit an async job
-# 2. Check job status
-# 3. Get the result
-#
-# Requirements:
-# - OPENAI_API_KEY environment variable set
-# - Jobs server running on http://127.0.0.1:8005
-#
-# Usage:
-#     bash cli_submit_poll_result.sh
-
-set -e
-
-API_URL="${PRAISONAI_BASE_URL:-http://127.0.0.1:8005}"
-
-echo "============================================================"
-echo "PraisonAI Async Jobs CLI Example"
-echo "============================================================"
-
-# Check if server is running
-echo ""
-echo "Checking server health..."
-if ! curl -s "$API_URL/health" > /dev/null 2>&1; then
-    echo "✗ Server not available at $API_URL"
-    echo "  Start the server with: python -m uvicorn praisonai.jobs.server:create_app --port 8005 --factory"
-    exit 1
-fi
-echo "✓ Server is healthy"
-
-# 1. Submit a job
-echo ""
-echo "1. Submitting job..."
-RESPONSE=$(curl -s -X POST "$API_URL/api/v1/runs" \
-    -H "Content-Type: application/json" \
-    -d '{"prompt": "What is 2+2? Answer with just the number."}')
-
-JOB_ID=$(echo "$RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin)['job_id'])")
-echo "   Job ID: $JOB_ID"
-
-# 2. Poll for status
-echo ""
-echo "2. Polling for status..."
-while true; do
-    STATUS_RESPONSE=$(curl -s "$API_URL/api/v1/runs/$JOB_ID")
-    STATUS=$(echo "$STATUS_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin)['status'])")
-    PROGRESS=$(echo "$STATUS_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin)['progress']['percentage'])")
-    
-    echo "   Status: $STATUS | Progress: ${PROGRESS}%"
-    
-    if [ "$STATUS" = "succeeded" ] || [ "$STATUS" = "failed" ] || [ "$STATUS" = "cancelled" ]; then
-        break
-    fi
-    
-    sleep 2
-done
-
-# 3. Get result
-echo ""
-echo "3. Getting result..."
-if [ "$STATUS" = "succeeded" ]; then
-    RESULT=$(curl -s "$API_URL/api/v1/runs/$JOB_ID/result")
-    echo "   Result: $(echo "$RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin)['result'])")"
-    echo "   Duration: $(echo "$RESULT" | python3 -c "import sys,json; print(f\"{json.load(sys.stdin)['duration_seconds']:.2f}s\")")"
-else
-    echo "   Job did not succeed: $STATUS"
-fi
-
-echo ""
-echo "============================================================"
-echo "Example completed!"
-echo "============================================================"

examples/async_runs/idempotency.sh

@@ -1,57 +0,0 @@
-#!/bin/bash
-# CLI Example: Idempotency Key Usage
-#
-# This example demonstrates how idempotency keys prevent duplicate job submissions.
-# Submitting the same request with the same idempotency key returns the existing job.
-#
-# Requirements:
-# - Jobs server running on http://127.0.0.1:8005
-#
-# Usage:
-#     bash idempotency.sh
-
-set -e
-
-API_URL="${PRAISONAI_BASE_URL:-http://127.0.0.1:8005}"
-IDEM_KEY="example-idem-key-$(date +%s)"
-
-echo "============================================================"
-echo "PraisonAI Idempotency Key Example"
-echo "============================================================"
-
-# First submission
-echo ""
-echo "1. First submission with Idempotency-Key: $IDEM_KEY"
-RESPONSE1=$(curl -s -X POST "$API_URL/api/v1/runs" \
-    -H "Content-Type: application/json" \
-    -H "Idempotency-Key: $IDEM_KEY" \
-    -d '{"prompt": "What is 1+1?"}')
-
-JOB_ID1=$(echo "$RESPONSE1" | python3 -c "import sys,json; print(json.load(sys.stdin)['job_id'])")
-echo "   Job ID: $JOB_ID1"
-
-# Second submission with same key
-echo ""
-echo "2. Second submission with SAME Idempotency-Key: $IDEM_KEY"
-RESPONSE2=$(curl -s -X POST "$API_URL/api/v1/runs" \
-    -H "Content-Type: application/json" \
-    -H "Idempotency-Key: $IDEM_KEY" \
-    -d '{"prompt": "Different prompt but same key"}')
-
-JOB_ID2=$(echo "$RESPONSE2" | python3 -c "import sys,json; print(json.load(sys.stdin)['job_id'])")
-echo "   Job ID: $JOB_ID2"
-
-# Verify same job ID
-echo ""
-echo "3. Verification:"
-if [ "$JOB_ID1" = "$JOB_ID2" ]; then
-    echo "   ✓ SUCCESS: Same job ID returned (no duplicate created)"
-else
-    echo "   ✗ FAILURE: Different job IDs returned"
-    exit 1
-fi
-
-echo ""
-echo "============================================================"
-echo "Idempotency example completed!"
-echo "============================================================"

examples/async_runs/sdk_submit_poll_result.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""
-SDK Example: Submit, Poll, and Get Result for Async Jobs
-
-This example demonstrates how to use the PraisonAI Jobs SDK to:
-1. Submit an async job
-2. Poll for status
-3. Get the result
-
-Requirements:
-- OPENAI_API_KEY environment variable set
-- Jobs server running on http://127.0.0.1:8005
-
-Usage:
-    python sdk_submit_poll_result.py
-"""
-
-import os
-import time
-import httpx
-
-# Configuration
-API_URL = os.getenv("PRAISONAI_BASE_URL", "http://127.0.0.1:8005")
-POLL_INTERVAL = 2  # seconds
-
-
-def submit_job(prompt: str, idempotency_key: str = None) -> dict:
-    """Submit a job and return the response."""
-    headers = {}
-    if idempotency_key:
-        headers["Idempotency-Key"] = idempotency_key
-    
-    with httpx.Client(timeout=30.0) as client:
-        response = client.post(
-            f"{API_URL}/api/v1/runs",
-            json={"prompt": prompt},
-            headers=headers if headers else None
-        )
-        response.raise_for_status()
-        return response.json()
-
-
-def get_status(job_id: str) -> dict:
-    """Get job status."""
-    with httpx.Client(timeout=30.0) as client:
-        response = client.get(f"{API_URL}/api/v1/runs/{job_id}")
-        response.raise_for_status()
-        return response.json()
-
-
-def get_result(job_id: str) -> dict:
-    """Get job result."""
-    with httpx.Client(timeout=30.0) as client:
-        response = client.get(f"{API_URL}/api/v1/runs/{job_id}/result")
-        response.raise_for_status()
-        return response.json()
-
-
-def wait_for_completion(job_id: str, max_wait: int = 120) -> dict:
-    """Poll until job completes."""
-    start = time.time()
-    while time.time() - start < max_wait:
-        status = get_status(job_id)
-        print(f"  Status: {status['status']} | Progress: {status['progress']['percentage']:.0f}%")
-        
-        if status["status"] in ("succeeded", "failed", "cancelled"):
-            return status
-        
-        # Honor retry_after if present
-        wait_time = status.get("retry_after") or POLL_INTERVAL
-        time.sleep(wait_time)
-    
-    raise TimeoutError(f"Job {job_id} did not complete within {max_wait}s")
-
-
-def main():
-    print("=" * 60)
-    print("PraisonAI Async Jobs SDK Example")
-    print("=" * 60)
-    
-    # Check if server is running
-    try:
-        with httpx.Client(timeout=5.0) as client:
-            health = client.get(f"{API_URL}/health")
-            health.raise_for_status()
-            print(f"✓ Server healthy: {health.json()['status']}")
-    except Exception as e:
-        print(f"✗ Server not available at {API_URL}: {e}")
-        print("  Start the server with: python -m uvicorn praisonai.jobs.server:create_app --port 8005 --factory")
-        return
-    
-    # 1. Submit a job
-    print("\n1. Submitting job...")
-    prompt = "What is the capital of France? Answer in one word."
-    result = submit_job(prompt)
-    job_id = result["job_id"]
-    print(f"   Job ID: {job_id}")
-    print(f"   Status: {result['status']}")
-    print(f"   Poll URL: {result['poll_url']}")
-    
-    # 2. Wait for completion
-    print("\n2. Waiting for completion...")
-    final_status = wait_for_completion(job_id)
-    print(f"   Final status: {final_status['status']}")
-    
-    # 3. Get result
-    if final_status["status"] == "succeeded":
-        print("\n3. Getting result...")
-        result = get_result(job_id)
-        print(f"   Result: {result['result']}")
-        print(f"   Duration: {result['duration_seconds']:.2f}s")
-    else:
-        print(f"\n3. Job did not succeed: {final_status.get('error', 'Unknown error')}")
-    
-    print("\n" + "=" * 60)
-    print("Example completed successfully!")
-    print("=" * 60)
-
-
-if __name__ == "__main__":
-    main()

examples/async_runs/sse_stream.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-# CLI Example: SSE Streaming
-#
-# This example demonstrates how to stream job progress via Server-Sent Events.
-#
-# Requirements:
-# - Jobs server running on http://127.0.0.1:8005
-#
-# Usage:
-#     bash sse_stream.sh
-
-set -e
-
-API_URL="${PRAISONAI_BASE_URL:-http://127.0.0.1:8005}"
-
-echo "============================================================"
-echo "PraisonAI SSE Streaming Example"
-echo "============================================================"
-
-# Submit a job
-echo ""
-echo "1. Submitting job..."
-RESPONSE=$(curl -s -X POST "$API_URL/api/v1/runs" \
-    -H "Content-Type: application/json" \
-    -d '{"prompt": "Count from 1 to 5."}')
-
-JOB_ID=$(echo "$RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin)['job_id'])")
-echo "   Job ID: $JOB_ID"
-
-# Stream progress
-echo ""
-echo "2. Streaming progress (Ctrl+C to stop)..."
-echo "   Connecting to: $API_URL/api/v1/runs/$JOB_ID/stream"
-echo ""
-
-# Use curl to stream SSE events (timeout after 60s)
-curl -s -N --max-time 60 "$API_URL/api/v1/runs/$JOB_ID/stream" | while read -r line; do
-    if [[ "$line" == data:* ]]; then
-        data="${line#data: }"
-        if [ "$data" = "[DONE]" ]; then
-            echo "   Stream completed"
-            break
-        fi
-        echo "   Event: $data"
-    fi
-done
-
-echo ""
-echo "============================================================"
-echo "Streaming example completed!"
-echo "============================================================"

examples/background/basic_background.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""
-Basic Background Tasks Example for PraisonAI Agents.
-
-This example demonstrates how to use the background task system with Agent:
-1. Create an Agent with background task support
-2. Run agent tasks asynchronously
-3. Track task progress
-4. Handle task completion
-
-Usage:
-    python basic_background.py
-"""
-
-import asyncio
-from praisonaiagents import Agent
-from praisonaiagents.background import BackgroundRunner, BackgroundConfig, TaskStatus
-
-
-async def main():
-    print("=" * 60)
-    print("Agent-Centric Background Tasks Demo")
-    print("=" * 60)
-    
-    # Create a background runner with config (used standalone, not passed to Agent)
-    runner = BackgroundRunner(config=BackgroundConfig(max_concurrent_tasks=3))
-    
-    # Create an Agent
-    agent = Agent(
-        name="AsyncAssistant",
-        instructions="You are a helpful research assistant.",
-    )
-    
-    print("\n--- Agent with Background Support Created ---")
-    print(f"Agent: {agent.name}")
-    print(f"Background runner: {runner is not None}")
-    
-    # Define some example tasks
-    async def research_task(topic: str) -> str:
-        """Simulate a research task."""
-        print(f"  🔄 Researching '{topic}'...")
-        await asyncio.sleep(1.5)
-        return f"Research on '{topic}' completed with 5 key findings"
-    
-    async def analysis_task(data: str) -> str:
-        """Simulate an analysis task."""
-        print(f"  🔄 Analyzing data...")
-        await asyncio.sleep(1.0)
-        return f"Analysis complete: {data}"
-    
-    # Submit tasks via background runner
-    print("\n--- Submitting Background Tasks ---")
-    
-    task1 = await runner.submit(
-        research_task, 
-        args=("AI trends 2025",), 
-        name="research_ai"
-    )
-    print(f"✅ Submitted research task: {task1.id[:8]}")
-    
-    task2 = await runner.submit(
-        analysis_task, 
-        args=("market data",), 
-        name="analyze_market"
-    )
-    print(f"✅ Submitted analysis task: {task2.id[:8]}")
-    
-    # List all tasks
-    print("\n--- Task Status ---")
-    for task in runner.tasks:
-        print(f"  [{task.id[:8]}] {task.status.value}")
-    
-    # Wait for tasks to complete
-    print("\n--- Waiting for Tasks ---")
-    await task1.wait(timeout=10.0)
-    await task2.wait(timeout=10.0)
-    
-    # Final results
-    print("\n--- Results ---")
-    for task in [task1, task2]:
-        status = "✅" if task.status == TaskStatus.COMPLETED else "❌"
-        print(f"  {status} {task.result}")
-    
-    # Cleanup
-    runner.clear_completed()
-    print("\n✅ Cleared completed tasks")
-    
-    print("\n" + "=" * 60)
-    print("Demo Complete!")
-    print("=" * 60)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

examples/basic/calculator_with_tests.py

@@ -1,23 +0,0 @@
-"""Calculator with Tests - Editor Output Example.
-
-Builds a calculator module, writes unit tests, runs them, generates a
-coverage-style report, and reads it back.
-"""
-from praisonaiagents import Agent
-from praisonaiagents.tools import (
-    write_file, read_file, execute_command
-)
-
-agent = Agent(
-    instructions="You are a helpful coding assistant.",
-    output="editor",
-    tools=[write_file, read_file, execute_command],
-    approval=True,
-)
-agent.start(
-    "Build a mini calculator - create /tmp/calculator.py with add, subtract, "
-    "multiply, divide functions, write unit tests in /tmp/test_calculator.py "
-    "using unittest, run the tests to make sure they pass, then generate a "
-    "coverage-style report in /tmp/calc_report.md listing which functions were "
-    "tested and read it back"
-)

examples/basic/fibonacci.py

@@ -1,22 +0,0 @@
-"""Fibonacci Generator - Editor Output Example.
-
-Creates a Fibonacci script, runs it, writes a summary, and reads back
-both files to verify everything looks good.
-"""
-from praisonaiagents import Agent
-from praisonaiagents.tools import (
-    write_file, read_file, execute_command, list_directory
-)
-
-agent = Agent(
-    instructions="You are a helpful coding assistant.",
-    output="editor",
-    tools=[write_file, read_file, execute_command, list_directory],
-    approval=True,
-)
-agent.start(
-    "Create a Python file at /tmp/fibonacci.py that generates the first 20 "
-    "Fibonacci numbers, run it to verify the output is correct, then write "
-    "a summary to /tmp/fib_summary.md explaining the algorithm you used and "
-    "the output, finally read back both files to confirm everything looks good"
-)

examples/basic/multi_step_research.py

@@ -1,36 +0,0 @@
-"""Multi-Step Research - Editor Output Example.
-
-Researches Python frameworks, creates comparison code, runs it, writes a
-markdown report, reads it back, lists files, and gets system info.
-"""
-from praisonaiagents import Agent
-from praisonaiagents.tools import (
-    write_file, read_file, execute_command, list_directory, get_system_info
-)
-
-try:
-    from praisonaiagents.tools import web_search
-    tools = [web_search, write_file, read_file, execute_command,
-             list_directory, get_system_info]
-except ImportError:
-    tools = [write_file, read_file, execute_command,
-             list_directory, get_system_info]
-
-agent = Agent(
-    instructions="You are a helpful research assistant.",
-    output="editor",
-    tools=tools,
-    approval=True,
-)
-agent.start(
-    "Research the top 3 Python web frameworks (Django, FastAPI, Flask), then: "
-    "1) Search the web for each framework's latest version and key features, "
-    "2) Create a file called /tmp/framework_comparison.py that contains a "
-    "Python dictionary with the comparison data, "
-    "3) Execute the code to verify the dictionary is valid, "
-    "4) Write a markdown report to /tmp/framework_report.md summarizing your "
-    "findings in a table format, "
-    "5) Read back the report file to verify it was written correctly, "
-    "6) List the files in /tmp to confirm both files exist, "
-    "7) Get system info to note what OS this report was generated on"
-)

examples/basic/system_audit.py

@@ -1,21 +0,0 @@
-"""System Audit - Editor Output Example.
-
-Runs system commands, gathers info, writes a report, and reads it back.
-"""
-from praisonaiagents import Agent
-from praisonaiagents.tools import (
-    write_file, read_file, execute_command
-)
-
-agent = Agent(
-    instructions="You are a helpful system administration assistant.",
-    output="editor",
-    tools=[write_file, read_file, execute_command],
-    approval=True,
-)
-agent.start(
-    "Investigate my system - get the current date, check disk usage, find out "
-    "what Python version is installed, list running processes sorted by memory, "
-    "then write all findings to /tmp/system_audit.md as a neat report and read "
-    "it back to verify"
-)

examples/basic/weather_search.py

@@ -1,28 +0,0 @@
-"""Weather Search - Editor Output Example.
-
-Searches for weather, creates JSON data, writes a parser script, executes
-it, and lists created files.
-"""
-from praisonaiagents import Agent
-from praisonaiagents.tools import (
-    write_file, execute_command, list_directory
-)
-
-try:
-    from praisonaiagents.tools import web_search
-    tools = [web_search, write_file, execute_command, list_directory]
-except ImportError:
-    tools = [write_file, execute_command, list_directory]
-
-agent = Agent(
-    instructions="You are a helpful research assistant.",
-    output="editor",
-    tools=tools,
-    approval=True,
-)
-agent.start(
-    "Search the web for the current weather in Tokyo, create a JSON file at "
-    "/tmp/weather_data.json with the findings, then write a Python script at "
-    "/tmp/parse_weather.py that reads the JSON and prints a formatted weather "
-    "report, execute the script, and list all files you created in /tmp"
-)

examples/benchmark/benchmark_example.py

@@ -1,146 +0,0 @@
-#!/usr/bin/env python3
-"""
-PraisonAI Benchmark Example
-
-This example demonstrates how to use the benchmark system programmatically
-to compare performance across different execution paths.
-
-Usage:
-    python benchmark_example.py
-    
-Requirements:
-    - OPENAI_API_KEY environment variable set
-    - praisonai package installed
-"""
-
-import os
-import sys
-
-# Ensure the package is importable
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../src/praisonai'))
-
-from praisonai.cli.features.benchmark import BenchmarkHandler, BenchmarkReport
-
-
-def run_quick_comparison():
-    """Run a quick comparison of key execution paths."""
-    print("=" * 60)
-    print("Quick Benchmark Comparison")
-    print("=" * 60)
-    
-    handler = BenchmarkHandler()
-    
-    # Run benchmark with 2 iterations on key paths
-    report = handler.run_full_benchmark(
-        prompt="What is 2+2?",
-        iterations=2,
-        paths=["openai_sdk", "praisonai_agent"],
-        output="verbose"
-    )
-    
-    # Print comparison table
-    print("\n" + handler.create_comparison_table(report))
-    
-    return report
-
-
-def run_full_benchmark():
-    """Run full benchmark suite across all paths."""
-    print("=" * 60)
-    print("Full Benchmark Suite")
-    print("=" * 60)
-    
-    handler = BenchmarkHandler()
-    
-    # Run full benchmark
-    report = handler.run_full_benchmark(
-        prompt="Hi",
-        iterations=3,
-        output="verbose"
-    )
-    
-    # Print full report
-    handler.print_report(report)
-    
-    return report
-
-
-def run_agent_benchmark():
-    """Benchmark PraisonAI Agent specifically."""
-    print("=" * 60)
-    print("Agent Benchmark")
-    print("=" * 60)
-    
-    handler = BenchmarkHandler()
-    
-    # Benchmark agent vs SDK
-    report = handler.run_full_benchmark(
-        prompt="Explain Python in one sentence",
-        iterations=3,
-        paths=["openai_sdk", "praisonai_agent"],
-        output="verbose"
-    )
-    
-    # Show timeline diagrams
-    for name, result in report.results.items():
-        print(f"\n### {name}")
-        print(handler.create_timeline_diagram(result))
-    
-    # Show variance analysis
-    print(handler.create_variance_table(report))
-    
-    return report
-
-
-def save_benchmark_results(report: BenchmarkReport, output_path: str):
-    """Save benchmark results to JSON file."""
-    import json
-    
-    with open(output_path, 'w') as f:
-        json.dump(report.to_dict(), f, indent=2)
-    
-    print(f"\nResults saved to: {output_path}")
-
-
-def main():
-    """Main entry point."""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="PraisonAI Benchmark Example")
-    parser.add_argument(
-        "--mode",
-        choices=["quick", "full", "agent"],
-        default="quick",
-        help="Benchmark mode: quick (2 paths), full (all paths), agent (agent focus)"
-    )
-    parser.add_argument(
-        "--output",
-        type=str,
-        default=None,
-        help="Output JSON file path"
-    )
-    
-    args = parser.parse_args()
-    
-    # Check for API key
-    if not os.environ.get("OPENAI_API_KEY"):
-        print("Error: OPENAI_API_KEY environment variable not set")
-        sys.exit(1)
-    
-    # Run selected benchmark
-    if args.mode == "quick":
-        report = run_quick_comparison()
-    elif args.mode == "full":
-        report = run_full_benchmark()
-    elif args.mode == "agent":
-        report = run_agent_benchmark()
-    
-    # Save results if requested
-    if args.output:
-        save_benchmark_results(report, args.output)
-    
-    print("\n✅ Benchmark complete!")
-
-
-if __name__ == "__main__":
-    main()

examples/caching/00_agent_caching_basic.py

@@ -1,43 +0,0 @@
-"""
-Basic Caching Configuration Example
-
-Demonstrates using caching for response and prompt caching.
-"""
-import os
-from praisonaiagents import Agent, CachingConfig
-
-# Ensure API key is set from environment
-assert os.getenv("OPENAI_API_KEY"), "OPENAI_API_KEY must be set"
-
-# Default caching (enabled)
-agent_cached = Agent(
-    instructions="You are a helpful assistant.",
-    caching=True,
-)
-
-# Disable caching
-agent_no_cache = Agent(
-    instructions="You are a helpful assistant.",
-    caching=False,
-)
-
-# Custom caching configuration
-agent_custom = Agent(
-    instructions="You are a helpful assistant.",
-    caching=CachingConfig(
-        enabled=True,
-        prompt_caching=True,  # Enable prompt caching for supported providers
-    ),
-)
-
-if __name__ == "__main__":
-    print("Testing CachingConfig...")
-    
-    print(f"Cached agent cache: {agent_cached.cache}")
-    print(f"No-cache agent cache: {agent_no_cache.cache}")
-    print(f"Custom agent cache: {agent_custom.cache}")
-    
-    result = agent_cached.chat("What is caching?")
-    print(f"Result: {result}")
-    
-    print("\nCachingConfig tests passed!")

examples/capabilities/assistants_example.py

@@ -1,24 +0,0 @@
-"""
-Assistants Capabilities Example
-
-Demonstrates OpenAI Assistants API using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import assistant_list
-
-print("=== List Assistants ===")
-try:
-    assistants = assistant_list()
-    print(f"Assistants found: {len(assistants)}")
-    for a in assistants[:5]:  # Show first 5
-        print(f"  - {a.get('name', 'unnamed')}: {a.get('id', 'unknown')}")
-except Exception as e:
-    print(f"Note: {e}")
-
-print("\n=== Assistant Operations ===")
-print("Available functions:")
-print("  assistant_create(name, instructions, model='gpt-4o-mini')")
-print("  assistant_list()")
-
-print("\nSee CLI: praisonai assistants list")
-print("See CLI: praisonai assistants create --name 'My Assistant'")

examples/capabilities/audio_example.py

@@ -1,24 +0,0 @@
-"""
-Audio Capabilities Example
-
-Demonstrates transcription and text-to-speech using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import transcribe, speech
-
-# Note: Audio transcription requires an audio file
-# This example shows the API structure
-
-print("=== Audio Transcription ===")
-print("To transcribe audio, use:")
-print("  result = transcribe('audio.mp3', model='whisper-1')")
-print("  print(result.text)")
-
-print("\n=== Text-to-Speech ===")
-print("To generate speech, use:")
-print("  audio_data = speech('Hello world', model='tts-1', voice='alloy')")
-print("  # Save to file or play")
-
-print("\nNote: These operations require audio files or generate audio output.")
-print("See CLI: praisonai audio transcribe <file>")
-print("See CLI: praisonai audio speech <text>")

examples/capabilities/batches_example.py

@@ -1,27 +0,0 @@
-"""
-Batches Capabilities Example
-
-Demonstrates batch processing using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import batch_list
-
-print("=== Batch List ===")
-try:
-    batches = batch_list()
-    print(f"Batches found: {len(batches)}")
-    for b in batches[:5]:  # Show first 5
-        print(f"  - {b.get('id', 'unknown')}: {b.get('status', 'unknown')}")
-except Exception as e:
-    print(f"Note: {e}")
-    print("Batch operations require batch jobs to be created first.")
-
-print("\n=== Batch Operations ===")
-print("Available functions:")
-print("  batch_create(input_file_id, endpoint, completion_window='24h')")
-print("  batch_list()")
-print("  batch_retrieve(batch_id)")
-print("  batch_cancel(batch_id)")
-
-print("\nSee CLI: praisonai batches list")
-print("See CLI: praisonai batches create <input_file_id>")

examples/capabilities/completions_example.py

@@ -1,30 +0,0 @@
-"""
-Completions Capability Example
-
-Demonstrates chat and text completions using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import chat_completion, text_completion
-
-# Chat completion example
-print("=== Chat Completion ===")
-result = chat_completion(
-    messages=[
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "What is 2 + 2? Answer in one word."}
-    ],
-    model="gpt-4o-mini",
-    max_tokens=10
-)
-print(f"Response: {result.content}")
-print(f"Model: {result.model}")
-print(f"Usage: {result.usage}")
-
-# Text completion example (legacy)
-print("\n=== Text Completion ===")
-result = text_completion(
-    prompt="The capital of France is",
-    model="gpt-3.5-turbo-instruct",
-    max_tokens=10
-)
-print(f"Response: {result.content}")

examples/capabilities/embeddings_example.py

@@ -1,46 +0,0 @@
-"""
-Embeddings Capability Example
-
-Demonstrates text embedding generation using PraisonAI capabilities.
-Both `embed` and `embedding` work identically - use whichever you prefer.
-"""
-
-from praisonai import embed, embedding  # Both work from top-level
-# Or: from praisonai.capabilities import embed, embedding
-
-# Single text embedding using embed()
-print("=== Single Text Embedding (using embed) ===")
-result = embed(
-    input="Hello, world!",
-    model="text-embedding-3-small"
-)
-print(f"Embedding dimensions: {len(result.embeddings[0])}")
-print(f"First 5 values: {result.embeddings[0][:5]}")
-print(f"Usage: {result.usage}")
-
-# Same thing using embedding() alias
-print("\n=== Single Text Embedding (using embedding alias) ===")
-result = embedding(
-    input="Hello, world!",
-    model="text-embedding-3-small"
-)
-print(f"Embedding dimensions: {len(result.embeddings[0])}")
-
-# Multiple text embeddings
-print("\n=== Multiple Text Embeddings ===")
-result = embed(
-    input=["Hello", "World", "AI"],
-    model="text-embedding-3-small"
-)
-print(f"Number of embeddings: {len(result.embeddings)}")
-for i, emb in enumerate(result.embeddings):
-    print(f"  Text {i+1}: {len(emb)} dimensions")
-
-# With custom dimensions (for models that support it)
-print("\n=== Custom Dimensions ===")
-result = embed(
-    input="Hello world",
-    model="text-embedding-3-large",
-    dimensions=256
-)
-print(f"Reduced dimensions: {len(result.embeddings[0])}")

examples/capabilities/files_example.py

@@ -1,28 +0,0 @@
-"""
-Files Capabilities Example
-
-Demonstrates file management using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import file_list
-
-print("=== File List ===")
-try:
-    files = file_list()
-    print(f"Files found: {len(files)}")
-    for f in files[:5]:  # Show first 5
-        print(f"  - {f.get('filename', 'unknown')}: {f.get('id', 'unknown')}")
-except Exception as e:
-    print(f"Note: {e}")
-    print("File operations require files to be uploaded first.")
-
-print("\n=== File Operations ===")
-print("Available functions:")
-print("  file_create(file_path, purpose='assistants')")
-print("  file_list(purpose=None)")
-print("  file_retrieve(file_id)")
-print("  file_delete(file_id)")
-print("  file_content(file_id)")
-
-print("\nSee CLI: praisonai files list")
-print("See CLI: praisonai files upload <file>")

examples/capabilities/images_example.py

@@ -1,31 +0,0 @@
-"""
-Images Capability Example
-
-Demonstrates image generation using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import image_generate
-
-# Generate an image with DALL-E 2
-print("=== Image Generation (DALL-E 2) ===")
-result = image_generate(
-    prompt="A simple blue circle on a white background",
-    model="dall-e-2",
-    size="256x256",
-    n=1
-)
-print(f"Images generated: {len(result)}")
-if result:
-    print(f"URL: {result[0].url[:80]}...")
-
-# Generate with DALL-E 3 (higher quality)
-print("\n=== Image Generation (DALL-E 3) ===")
-result = image_generate(
-    prompt="A serene mountain landscape at sunset",
-    model="dall-e-3",
-    size="1024x1024",
-    quality="standard"
-)
-print(f"Images generated: {len(result)}")
-if result:
-    print(f"Revised prompt: {result[0].revised_prompt[:80]}..." if result[0].revised_prompt else "No revised prompt")

examples/capabilities/messages_example.py

@@ -1,33 +0,0 @@
-"""
-Messages Capability Example
-
-Demonstrates Anthropic-style messages API and token counting.
-"""
-
-from praisonai.capabilities import messages_create, count_tokens
-
-# Create a message (Anthropic-style)
-print("=== Messages Create ===")
-result = messages_create(
-    messages=[{"role": "user", "content": "What is the meaning of life? Answer briefly."}],
-    model="gpt-4o-mini",  # Works with any model via LiteLLM
-    max_tokens=100,
-    system="You are a philosophical assistant."
-)
-print(f"Message ID: {result.id}")
-if result.content:
-    for block in result.content:
-        if block.get("type") == "text":
-            print(f"Response: {block.get('text')}")
-print(f"Usage: {result.usage}")
-
-# Count tokens
-print("\n=== Token Counting ===")
-result = count_tokens(
-    messages=[
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "Hello, how are you today?"}
-    ],
-    model="gpt-4o-mini"
-)
-print(f"Token count: {result.input_tokens}")

examples/capabilities/moderations_example.py

@@ -1,24 +0,0 @@
-"""
-Moderations Capability Example
-
-Demonstrates content moderation using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import moderate
-
-# Check safe content
-print("=== Safe Content Check ===")
-result = moderate(
-    input="Hello, how are you today?"
-)
-print(f"Flagged: {result[0].flagged}")
-print(f"Categories: {list(result[0].categories.keys())[:5]}...")
-
-# Check multiple texts
-print("\n=== Multiple Text Moderation ===")
-result = moderate(
-    input=["Hello world", "Have a nice day", "This is a test"]
-)
-print(f"Number of results: {len(result)}")
-for i, r in enumerate(result):
-    print(f"  Text {i+1}: Flagged = {r.flagged}")

examples/capabilities/realtime_example.py

@@ -1,23 +0,0 @@
-"""
-Realtime Capability Example
-
-Demonstrates realtime session creation for audio/video streaming.
-"""
-
-from praisonai.capabilities import realtime_connect
-
-# Create a realtime session
-print("=== Realtime Session ===")
-session = realtime_connect(
-    model="gpt-4o-realtime-preview",
-    modalities=["text", "audio"],
-    voice="alloy"
-)
-print(f"Session ID: {session.id}")
-print(f"Status: {session.status}")
-print(f"URL: {session.url}")
-print(f"Modalities: {session.metadata.get('modalities')}")
-print(f"Voice: {session.metadata.get('voice')}")
-
-print("\nNote: To use this session, connect via WebSocket to the URL above.")
-print("See OpenAI Realtime API documentation for WebSocket protocol details.")

examples/capabilities/rerank_example.py

@@ -1,32 +0,0 @@
-"""
-Rerank Capabilities Example
-
-Demonstrates document reranking using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import rerank
-
-print("=== Document Reranking ===")
-try:
-    documents = [
-        "Python is a programming language",
-        "Machine learning uses algorithms",
-        "Python is great for data science",
-        "JavaScript runs in browsers"
-    ]
-    
-    results = rerank(
-        query="Python programming",
-        documents=documents,
-        model="cohere/rerank-english-v3.0"
-    )
-    
-    print(f"Query: 'Python programming'")
-    print(f"Reranked results:")
-    for r in results:
-        print(f"  Score {r.get('relevance_score', 0):.4f}: {r.get('document', {}).get('text', '')[:50]}")
-except Exception as e:
-    print(f"Note: Reranking requires Cohere API key")
-    print(f"Error: {e}")
-
-print("\nSee CLI: praisonai rerank <query> --documents 'doc1' 'doc2'")

examples/capabilities/vector_stores_example.py

@@ -1,22 +0,0 @@
-"""
-Vector Stores Capabilities Example
-
-Demonstrates vector store management using PraisonAI capabilities.
-"""
-
-from praisonai.capabilities import vector_store_create, vector_store_search
-
-print("=== Vector Store Operations ===")
-print("Available functions:")
-print("  vector_store_create(name)")
-print("  vector_store_search(vector_store_id, query)")
-
-print("\n=== Create Vector Store ===")
-try:
-    store = vector_store_create(name="test-store")
-    print(f"Created: {store}")
-except Exception as e:
-    print(f"Note: {e}")
-
-print("\nSee CLI: praisonai vector-stores create --name 'my-store'")
-print("See CLI: praisonai vector-stores search <store_id> <query>")

examples/catalog/fetch_templates.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example: Fetch and search PraisonAI templates from the catalog.
-
-This example demonstrates how to:
-- Fetch templates.json from the deployed catalog
-- Search templates by keyword
-- Filter by tags and requirements
-- Generate CLI commands
-"""
-
-import json
-import urllib.request
-from typing import List, Dict, Any, Optional
-
-CATALOG_URL = "https://mervinpraison.github.io/praisonai-template-catalog/data/templates.json"
-
-
-def fetch_catalog(url: str = CATALOG_URL) -> Dict[str, Any]:
-    """Fetch the template catalog from URL."""
-    try:
-        with urllib.request.urlopen(url, timeout=10) as response:
-            return json.loads(response.read().decode())
-    except Exception as e:
-        print(f"Failed to fetch catalog: {e}")
-        # Return empty catalog on failure
-        return {"version": "0.0.0", "count": 0, "templates": []}
-
-
-def search_templates(templates: List[Dict], query: str) -> List[Dict]:
-    """Search templates by name, description, or tags."""
-    query = query.lower()
-    results = []
-    for t in templates:
-        if (query in t.get("name", "").lower() or 
-            query in t.get("description", "").lower() or
-            any(query in tag.lower() for tag in t.get("tags", []))):
-            results.append(t)
-    return results
-
-
-def filter_by_tags(templates: List[Dict], tags: List[str]) -> List[Dict]:
-    """Filter templates that have all specified tags."""
-    return [
-        t for t in templates
-        if all(tag in t.get("tags", []) for tag in tags)
-    ]
-
-
-def filter_by_tool(templates: List[Dict], tool_name: str) -> List[Dict]:
-    """Filter templates that require a specific tool."""
-    return [
-        t for t in templates
-        if tool_name in t.get("requires", {}).get("tools", [])
-    ]
-
-
-def get_template(templates: List[Dict], name: str) -> Optional[Dict]:
-    """Get a template by name."""
-    for t in templates:
-        if t.get("name") == name:
-            return t
-    return None
-
-
-def generate_cli_command(template: Dict, action: str = "run") -> str:
-    """Generate CLI command for a template."""
-    name = template.get("name", "unknown")
-    if action == "run":
-        return f"praisonai templates run {name}"
-    elif action == "info":
-        return f"praisonai templates info {name}"
-    elif action == "init":
-        return f"praisonai templates init my-project --template {name}"
-    return f"praisonai templates {action} {name}"
-
-
-def print_template_summary(template: Dict):
-    """Print a summary of a template."""
-    print(f"\n{'='*60}")
-    print(f"Name: {template.get('name')}")
-    print(f"Version: {template.get('version')}")
-    print(f"Description: {template.get('description', '')[:100]}...")
-    print(f"Tags: {', '.join(template.get('tags', []))}")
-    
-    requires = template.get("requires", {})
-    if requires.get("tools"):
-        print(f"Tools: {', '.join(requires['tools'])}")
-    if requires.get("packages"):
-        print(f"Packages: {', '.join(requires['packages'])}")
-    if requires.get("env"):
-        print(f"Env vars: {', '.join(requires['env'])}")
-    
-    print(f"\nRun: {generate_cli_command(template, 'run')}")
-    print(f"{'='*60}")
-
-
-def main():
-    print("PraisonAI Template Catalog - Python Example")
-    print("-" * 45)
-    
-    # Fetch catalog
-    print("\n1. Fetching template catalog...")
-    catalog = fetch_catalog()
-    templates = catalog.get("templates", [])
-    
-    print(f"   Catalog version: {catalog.get('version', 'unknown')}")
-    print(f"   Total templates: {len(templates)}")
-    
-    if not templates:
-        print("   No templates found. The catalog may not be deployed yet.")
-        print("   Try building locally: praisonai templates catalog build")
-        return
-    
-    # List all templates
-    print("\n2. Available templates:")
-    for t in templates:
-        print(f"   - {t.get('name')} (v{t.get('version')})")
-    
-    # Search for video templates
-    print("\n3. Searching for 'video' templates...")
-    video_templates = search_templates(templates, "video")
-    print(f"   Found {len(video_templates)} video templates:")
-    for t in video_templates:
-        print(f"   - {t.get('name')}: {t.get('description', '')[:50]}...")
-    
-    # Filter by tool
-    print("\n4. Templates using 'shell_tool':")
-    shell_templates = filter_by_tool(templates, "shell_tool")
-    for t in shell_templates:
-        print(f"   - {t.get('name')}")
-    
-    # Get specific template details
-    if templates:
-        first_template = templates[0]
-        print(f"\n5. Template details for '{first_template.get('name')}':")
-        print_template_summary(first_template)
-    
-    # Generate CLI commands
-    print("\n6. CLI commands for all templates:")
-    for t in templates[:5]:  # First 5 only
-        print(f"   {generate_cli_command(t, 'run')}")
-    
-    print("\nDone!")
-
-
-if __name__ == "__main__":
-    main()

examples/catalog/fetch_templates.ts

@@ -1,167 +0,0 @@
-#!/usr/bin/env npx ts-node
-/**
- * Example: Fetch and search PraisonAI templates from the catalog.
- * 
- * This TypeScript example demonstrates how to:
- * - Fetch templates.json from the deployed catalog
- * - Search templates by keyword
- * - Filter by tags and requirements
- * - Generate CLI commands
- */
-
-const CATALOG_URL = "https://mervinpraison.github.io/praisonai-template-catalog/data/templates.json";
-
-interface Template {
-  name: string;
-  version: string;
-  description: string;
-  author?: string;
-  license?: string;
-  tags?: string[];
-  category?: string;
-  difficulty?: "beginner" | "intermediate" | "advanced";
-  requires?: {
-    tools?: string[];
-    packages?: string[];
-    env?: string[];
-  };
-}
-
-interface Catalog {
-  version: string;
-  generated_at: string;
-  count: number;
-  templates: Template[];
-}
-
-async function fetchCatalog(url: string = CATALOG_URL): Promise<Catalog> {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch catalog: ${response.statusText}`);
-  }
-  return response.json();
-}
-
-function searchTemplates(templates: Template[], query: string): Template[] {
-  const q = query.toLowerCase();
-  return templates.filter(t =>
-    t.name.toLowerCase().includes(q) ||
-    t.description?.toLowerCase().includes(q) ||
-    t.tags?.some(tag => tag.toLowerCase().includes(q))
-  );
-}
-
-function filterByTags(templates: Template[], tags: string[]): Template[] {
-  return templates.filter(t =>
-    tags.every(tag => t.tags?.includes(tag))
-  );
-}
-
-function filterByTool(templates: Template[], toolName: string): Template[] {
-  return templates.filter(t =>
-    t.requires?.tools?.includes(toolName)
-  );
-}
-
-function getTemplate(templates: Template[], name: string): Template | undefined {
-  return templates.find(t => t.name === name);
-}
-
-function generateCLICommand(template: Template, action: string = "run"): string {
-  const name = template.name;
-  switch (action) {
-    case "run":
-      return `praisonai templates run ${name}`;
-    case "info":
-      return `praisonai templates info ${name}`;
-    case "init":
-      return `praisonai templates init my-project --template ${name}`;
-    default:
-      return `praisonai templates ${action} ${name}`;
-  }
-}
-
-function printTemplateSummary(template: Template): void {
-  console.log("\n" + "=".repeat(60));
-  console.log(`Name: ${template.name}`);
-  console.log(`Version: ${template.version}`);
-  console.log(`Description: ${template.description?.slice(0, 100)}...`);
-  console.log(`Tags: ${template.tags?.join(", ") || "none"}`);
-  
-  const requires = template.requires;
-  if (requires?.tools?.length) {
-    console.log(`Tools: ${requires.tools.join(", ")}`);
-  }
-  if (requires?.packages?.length) {
-    console.log(`Packages: ${requires.packages.join(", ")}`);
-  }
-  if (requires?.env?.length) {
-    console.log(`Env vars: ${requires.env.join(", ")}`);
-  }
-  
-  console.log(`\nRun: ${generateCLICommand(template, "run")}`);
-  console.log("=".repeat(60));
-}
-
-async function main(): Promise<void> {
-  console.log("PraisonAI Template Catalog - TypeScript Example");
-  console.log("-".repeat(45));
-  
-  // Fetch catalog
-  console.log("\n1. Fetching template catalog...");
-  let catalog: Catalog;
-  try {
-    catalog = await fetchCatalog();
-  } catch (error) {
-    console.log(`   Failed to fetch: ${error}`);
-    console.log("   The catalog may not be deployed yet.");
-    return;
-  }
-  
-  const templates = catalog.templates;
-  console.log(`   Catalog version: ${catalog.version}`);
-  console.log(`   Total templates: ${templates.length}`);
-  
-  if (templates.length === 0) {
-    console.log("   No templates found.");
-    return;
-  }
-  
-  // List all templates
-  console.log("\n2. Available templates:");
-  templates.forEach(t => {
-    console.log(`   - ${t.name} (v${t.version})`);
-  });
-  
-  // Search for video templates
-  console.log("\n3. Searching for 'video' templates...");
-  const videoTemplates = searchTemplates(templates, "video");
-  console.log(`   Found ${videoTemplates.length} video templates:`);
-  videoTemplates.forEach(t => {
-    console.log(`   - ${t.name}: ${t.description?.slice(0, 50)}...`);
-  });
-  
-  // Filter by tool
-  console.log("\n4. Templates using 'shell_tool':");
-  const shellTemplates = filterByTool(templates, "shell_tool");
-  shellTemplates.forEach(t => {
-    console.log(`   - ${t.name}`);
-  });
-  
-  // Get specific template details
-  if (templates.length > 0) {
-    const firstTemplate = templates[0];
-    console.log(`\n5. Template details for '${firstTemplate.name}':`);
-    printTemplateSummary(firstTemplate);
-  }
-  
-  // Generate CLI commands
-  console.log("\n6. CLI commands for all templates:");
-  templates.slice(0, 5).forEach(t => {
-    console.log(`   ${generateCLICommand(t, "run")}`);
-  });
-  
-  console.log("\nDone!");
-}
-
-main().catch(console.error);

examples/catalog/run_all_catalog_examples.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""
-Run all catalog examples and report pass/fail status.
-
-Usage:
-    python run_all_catalog_examples.py
-    
-Environment variables:
-    OPENAI_API_KEY or PRAISONAI_OPENAI_API_KEY - Required for agent example
-    PRAISONAI_RUN_INTEGRATION - Set to "1" to run integration tests
-"""
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-SCRIPT_DIR = Path(__file__).parent
-
-
-def run_example(name: str, script: str, requires_api_key: bool = False) -> bool:
-    """Run an example script and return success status."""
-    print(f"\n{'='*60}")
-    print(f"Running: {name}")
-    print(f"Script: {script}")
-    print("="*60)
-    
-    # Check API key requirement
-    if requires_api_key:
-        api_key = os.environ.get("OPENAI_API_KEY") or os.environ.get("PRAISONAI_OPENAI_API_KEY")
-        run_integration = os.environ.get("PRAISONAI_RUN_INTEGRATION") == "1"
-        
-        if not api_key:
-            print(f"⏭️  SKIPPED: {name} (no API key)")
-            print("   Set OPENAI_API_KEY to run this example")
-            return True  # Not a failure, just skipped
-        
-        if not run_integration:
-            print(f"⏭️  SKIPPED: {name} (integration tests disabled)")
-            print("   Set PRAISONAI_RUN_INTEGRATION=1 to run")
-            return True
-    
-    script_path = SCRIPT_DIR / script
-    if not script_path.exists():
-        print(f"❌ FAILED: Script not found: {script_path}")
-        return False
-    
-    try:
-        result = subprocess.run(
-            [sys.executable, str(script_path)],
-            capture_output=True,
-            text=True,
-            timeout=60,
-            cwd=str(SCRIPT_DIR)
-        )
-        
-        print(result.stdout)
-        if result.stderr:
-            print(f"STDERR: {result.stderr}")
-        
-        if result.returncode == 0:
-            print(f"✅ PASSED: {name}")
-            return True
-        else:
-            print(f"❌ FAILED: {name} (exit code {result.returncode})")
-            return False
-            
-    except subprocess.TimeoutExpired:
-        print(f"❌ FAILED: {name} (timeout)")
-        return False
-    except Exception as e:
-        print(f"❌ FAILED: {name} ({e})")
-        return False
-
-
-def main():
-    print("PraisonAI Template Catalog - Example Runner")
-    print("=" * 50)
-    
-    # Check environment
-    api_key = os.environ.get("OPENAI_API_KEY") or os.environ.get("PRAISONAI_OPENAI_API_KEY")
-    if api_key:
-        print(f"API key: present (...{api_key[-4:]})")
-    else:
-        print("API key: not set")
-    
-    run_integration = os.environ.get("PRAISONAI_RUN_INTEGRATION") == "1"
-    print(f"Integration tests: {'enabled' if run_integration else 'disabled'}")
-    
-    # Define examples
-    examples = [
-        ("Fetch Templates (Python)", "fetch_templates.py", False),
-        ("Template Finder Agent", "template_finder_agent.py", True),
-    ]
-    
-    # Run examples
-    results = []
-    for name, script, requires_key in examples:
-        success = run_example(name, script, requires_key)
-        results.append((name, success))
-    
-    # Summary
-    print("\n" + "=" * 60)
-    print("SUMMARY")
-    print("=" * 60)
-    
-    passed = sum(1 for _, s in results if s)
-    failed = sum(1 for _, s in results if not s)
-    
-    for name, success in results:
-        status = "✅ PASS" if success else "❌ FAIL"
-        print(f"  {status}: {name}")
-    
-    print(f"\nTotal: {passed} passed, {failed} failed")
-    
-    # Exit with appropriate code
-    sys.exit(0 if failed == 0 else 1)
-
-
-if __name__ == "__main__":
-    main()

examples/catalog/template_finder_agent.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example: Template Finder Agent
-
-An Agent()-centric example that uses an AI agent to find templates
-based on natural language queries.
-
-Requires: OPENAI_API_KEY environment variable
-"""
-
-import json
-import os
-import urllib.request
-
-CATALOG_URL = "https://mervinpraison.github.io/praisonai-template-catalog/data/templates.json"
-
-
-def fetch_templates() -> list:
-    """Fetch templates from catalog."""
-    try:
-        with urllib.request.urlopen(CATALOG_URL, timeout=10) as response:
-            data = json.loads(response.read().decode())
-            return data.get("templates", [])
-    except Exception:
-        return []
-
-
-def search_templates_tool(query: str) -> str:
-    """
-    Search templates by keyword.
-    
-    Args:
-        query: Search query (e.g., "video editing", "transcript", "data")
-    
-    Returns:
-        JSON string with matching templates
-    """
-    templates = fetch_templates()
-    query_lower = query.lower()
-    
-    results = []
-    for t in templates:
-        if (query_lower in t.get("name", "").lower() or
-            query_lower in t.get("description", "").lower() or
-            any(query_lower in tag.lower() for tag in t.get("tags", []))):
-            results.append({
-                "name": t.get("name"),
-                "description": t.get("description", "")[:100],
-                "tags": t.get("tags", []),
-                "cli_command": f"praisonai templates run {t.get('name')}"
-            })
-    
-    if not results:
-        return json.dumps({"message": "No templates found matching your query", "templates": []})
-    
-    return json.dumps({"count": len(results), "templates": results})
-
-
-def list_all_templates_tool() -> str:
-    """
-    List all available templates.
-    
-    Returns:
-        JSON string with all template names and descriptions
-    """
-    templates = fetch_templates()
-    
-    if not templates:
-        return json.dumps({"message": "No templates available", "templates": []})
-    
-    results = [
-        {"name": t.get("name"), "description": t.get("description", "")[:80]}
-        for t in templates
-    ]
-    
-    return json.dumps({"count": len(results), "templates": results})
-
-
-def get_template_details_tool(name: str) -> str:
-    """
-    Get detailed information about a specific template.
-    
-    Args:
-        name: Template name (e.g., "ai-video-editor")
-    
-    Returns:
-        JSON string with template details
-    """
-    templates = fetch_templates()
-    
-    for t in templates:
-        if t.get("name") == name:
-            return json.dumps({
-                "name": t.get("name"),
-                "version": t.get("version"),
-                "description": t.get("description"),
-                "author": t.get("author"),
-                "tags": t.get("tags", []),
-                "requires": t.get("requires", {}),
-                "cli_commands": {
-                    "run": f"praisonai templates run {name}",
-                    "info": f"praisonai templates info {name}",
-                    "init": f"praisonai templates init my-project --template {name}"
-                }
-            })
-    
-    return json.dumps({"error": f"Template '{name}' not found"})
-
-
-def check_api_key() -> bool:
-    """Check if API key is available."""
-    key = os.environ.get("OPENAI_API_KEY") or os.environ.get("PRAISONAI_OPENAI_API_KEY")
-    if key:
-        print(f"API key present: ...{key[-4:]}")
-        return True
-    return False
-
-
-def main():
-    print("PraisonAI Template Finder Agent")
-    print("=" * 40)
-    
-    # Check for API key
-    if not check_api_key():
-        print("\n⚠️  No API key found.")
-        print("Set OPENAI_API_KEY or PRAISONAI_OPENAI_API_KEY to use the agent.")
-        print("\nFalling back to direct tool usage:\n")
-        
-        # Demo the tools directly
-        print("1. Listing all templates:")
-        result = list_all_templates_tool()
-        data = json.loads(result)
-        for t in data.get("templates", [])[:5]:
-            print(f"   - {t['name']}: {t['description'][:50]}...")
-        
-        print("\n2. Searching for 'video' templates:")
-        result = search_templates_tool("video")
-        data = json.loads(result)
-        for t in data.get("templates", []):
-            print(f"   - {t['name']}")
-            print(f"     Run: {t['cli_command']}")
-        
-        return
-    
-    # Import Agent only if API key is available
-    try:
-        from praisonaiagents import Agent
-    except ImportError:
-        print("praisonaiagents not installed. Install with: pip install praisonaiagents")
-        return
-    
-    # Create the Template Finder Agent
-    agent = Agent(
-        name="Template Finder",
-        role="PraisonAI Template Expert",
-        goal="Help users find the right template for their needs",
-        backstory="""You are an expert on PraisonAI templates. You help users 
-        discover templates that match their requirements. You can search templates,
-        list all available templates, and provide detailed information about specific
-        templates. Always provide the CLI command to run the template.""",
-        tools=[
-            search_templates_tool,
-            list_all_templates_tool,
-            get_template_details_tool
-        ],
-        output="verbose"  # Use new consolidated param
-    )
-    
-    # Example queries
-    queries = [
-        "Find me a template for editing videos",
-        "What templates are available for working with transcripts?",
-        "Show me details about the ai-video-editor template"
-    ]
-    
-    print("\nRunning Template Finder Agent...")
-    print("-" * 40)
-    
-    for query in queries:
-        print(f"\n📝 Query: {query}")
-        print("-" * 40)
-        
-        try:
-            result = agent.start(query)
-            print(f"\n🤖 Response:\n{result}")
-        except Exception as e:
-            print(f"Error: {e}")
-        
-        print("\n" + "=" * 40)
-
-
-if __name__ == "__main__":
-    main()

examples/checkpoints/basic_checkpoints.py

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-"""
-Basic Checkpoints Example for PraisonAI Agents.
-
-This example demonstrates how to use the shadow git checkpointing system with Agent:
-1. Create an Agent with checkpoint support
-2. Save checkpoints before making changes
-3. List available checkpoints
-4. Restore to a previous checkpoint
-
-Usage:
-    python basic_checkpoints.py
-"""
-
-import asyncio
-import tempfile
-from pathlib import Path
-
-from praisonaiagents import Agent
-from praisonaiagents.checkpoints import CheckpointService
-
-
-async def main():
-    # Create a temporary workspace for demonstration
-    with tempfile.TemporaryDirectory() as workspace:
-        print("=" * 60)
-        print("Agent-Centric Checkpointing Demo")
-        print("=" * 60)
-        print(f"\nWorkspace: {workspace}")
-        
-        # Create some initial files
-        test_file = Path(workspace) / "example.py"
-        test_file.write_text("# Initial content\nprint('Hello, World!')\n")
-        print(f"\n✅ Created initial file: {test_file.name}")
-        
-        # Create checkpoint service (used standalone, not passed to Agent)
-        checkpoint_service = CheckpointService(workspace_dir=workspace)
-        
-        # Create an Agent
-        agent = Agent(
-            name="RefactorBot",
-            instructions="You are a code refactoring assistant.",
-        )
-        
-        print("\n--- Agent with Checkpoint Support Created ---")
-        print(f"Agent: {agent.name}")
-        print(f"Checkpoint service initialized: {checkpoint_service is not None}")
-        
-        try:
-            # Initialize the shadow git repository
-            print("\n--- Initializing Checkpoint Service ---")
-            await checkpoint_service.initialize()
-            print("✅ Shadow git repository initialized")
-            
-            # Save first checkpoint
-            print("\n--- Saving Checkpoint 1: Initial State ---")
-            result1 = await checkpoint_service.save("Initial state")
-            print(f"✅ Checkpoint saved: {result1.checkpoint.id[:8]}")
-            print(f"   Message: {result1.checkpoint.message}")
-            
-            # Make some changes (simulating agent modifications)
-            print("\n--- Simulating Agent Changes ---")
-            test_file.write_text("# Refactored content\nprint('Hello, PraisonAI!')\nprint('Checkpoints are awesome!')\n")
-            print("✅ Modified example.py")
-            
-            # Create a new file
-            new_file = Path(workspace) / "utils.py"
-            new_file.write_text("def helper():\n    return 'I help!'\n")
-            print("✅ Created utils.py")
-            
-            # Save second checkpoint
-            print("\n--- Saving Checkpoint 2: After Refactoring ---")
-            result2 = await checkpoint_service.save("Added features")
-            print(f"✅ Checkpoint saved: {result2.checkpoint.id[:8]}")
-            
-            # List all checkpoints
-            print("\n--- Listing All Checkpoints ---")
-            checkpoints_list = await checkpoint_service.list_checkpoints()
-            for i, cp in enumerate(checkpoints_list, 1):
-                print(f"  {i}. [{cp.id[:8]}] {cp.message}")
-            
-            # Show diff
-            print("\n--- Current Diff ---")
-            diff = await checkpoint_service.diff()
-            if diff.files:
-                for f in diff.files:
-                    print(f"  {f.status}: {f.path}")
-            else:
-                print("  No uncommitted changes")
-            
-            # Make more changes
-            test_file.write_text("# Bad changes\nprint('This will be reverted')\n")
-            print("\n✅ Made problematic changes to example.py")
-            
-            # Restore to checkpoint 2
-            print(f"\n--- Restoring to Checkpoint: {result2.checkpoint.id[:8]} ---")
-            await checkpoint_service.restore(result2.checkpoint.id)
-            print("✅ Restored successfully!")
-            
-            # Verify restoration
-            content = test_file.read_text()
-            print(f"\n--- Verified Content After Restore ---")
-            print(content)
-            
-        except Exception as e:
-            print(f"\n❌ Error: {e}")
-            raise
-        
-        print("\n" + "=" * 60)
-        print("Demo Complete!")
-        print("=" * 60)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

examples/cli/calculator_with_tests.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-# Calculator with tests: code + unit tests + test execution + coverage report
-# Tests: multiple file creation, test execution, report generation, file reading
-
-praisonai "Build a mini calculator - create /tmp/calculator.py with add, subtract, multiply, divide functions, write unit tests in /tmp/test_calculator.py using unittest, run the tests to make sure they pass, then generate a coverage-style report in /tmp/calc_report.md listing which functions were tested and read it back" --trust

examples/cli/fibonacci_generator.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-# Fibonacci generator: code creation, execution, documentation, verification
-# Tests: file creation, code execution, markdown writing, file reading
-
-praisonai "Create a Python file at /tmp/fibonacci.py that generates the first 20 Fibonacci numbers, run it to verify the output is correct, then write a summary to /tmp/fib_summary.md explaining the algorithm you used and the output, finally read back both files to confirm everything looks good" --trust

examples/cli/multi_step_research.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-# Multi-step research: web search, file creation, code execution, reporting
-# Tests: web search, file write, code execution, markdown report, file read, directory listing, system info
-
-praisonai "Research the top 3 Python web frameworks (Django, FastAPI, Flask), then: 1) Search the web for each framework's latest version and key features, 2) Create a file called /tmp/framework_comparison.py that contains a Python dictionary with the comparison data, 3) Execute the code to verify the dictionary is valid, 4) Write a markdown report to /tmp/framework_report.md summarizing your findings in a table format, 5) Read back the report file to verify it was written correctly, 6) List the files in /tmp to confirm both files exist, 7) Get system info to note what OS this report was generated on, 8) Analyze the Python code you wrote for any issues, 9) Format the Python code properly, 10) Finally search for any recent news about Python 3.13 features" --trust

examples/cli/persistence_commands.md

@@ -1,93 +0,0 @@
-# Persistence CLI Commands
-
-## Quick Reference
-
-```bash
-# Check database connectivity
-praisonai persistence doctor \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --state-url redis://localhost:6379
-
-# Run agent with persistence
-praisonai persistence run \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --session-id my-session
-
-# Resume a session
-praisonai persistence resume \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --session-id my-session
-
-# Export session to file
-praisonai persistence export \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --session-id my-session \
-  --output session_backup.jsonl
-
-# Import session from file
-praisonai persistence import \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --file session_backup.jsonl
-
-# Check schema status
-praisonai persistence status \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --state-url redis://localhost:6379
-
-# Apply migrations
-praisonai persistence migrate \
-  --conversation-url postgresql://localhost:5432/praisonai \
-  --state-url redis://localhost:6379
-```
-
-## Environment Variables
-
-Instead of CLI flags, you can use environment variables:
-
-```bash
-export PRAISON_CONVERSATION_URL=postgresql://localhost:5432/praisonai
-export PRAISON_STATE_URL=redis://localhost:6379
-export PRAISON_KNOWLEDGE_URL=http://localhost:6333
-
-# Then run without URL flags
-praisonai persistence doctor
-praisonai persistence status
-```
-
-## Docker Setup
-
-```bash
-# Start all services
-docker run -d --name praison-postgres \
-  -e POSTGRES_PASSWORD=praison123 \
-  -e POSTGRES_DB=praisonai \
-  -p 5432:5432 postgres:16
-
-docker run -d --name praison-redis \
-  -p 6379:6379 redis:7
-
-docker run -d --name praison-qdrant \
-  -p 6333:6333 -p 6334:6334 qdrant/qdrant
-
-# Verify
-docker ps
-```
-
-## Example Workflow
-
-```bash
-# 1. Start services
-docker-compose up -d
-
-# 2. Check connectivity
-praisonai persistence doctor
-
-# 3. Run agent
-praisonai persistence run --session-id demo-session
-
-# 4. Export for backup
-praisonai persistence export --session-id demo-session --output backup.jsonl
-
-# 5. Import to another environment
-praisonai persistence import --file backup.jsonl
-```

examples/cli/persistence_end_to_end.md

@@ -1,124 +0,0 @@
-# PraisonAI Persistence CLI - End-to-End Guide
-
-This guide demonstrates the CLI commands for database persistence.
-
-## Prerequisites
-
-```bash
-pip install "praisonai[tools]"
-
-# Start Docker containers
-docker run -d --name praison-postgres -p 5432:5432 \
-    -e POSTGRES_PASSWORD=praison123 \
-    -e POSTGRES_DB=praisonai \
-    postgres:16
-
-docker run -d --name praison-qdrant -p 6333:6333 qdrant/qdrant
-docker run -d --name praison-redis -p 6379:6379 redis:7
-```
-
-## 1. Doctor Command - Validate Connectivity
-
-```bash
-# Check all stores
-praisonai persistence doctor \
-    --conversation-url "postgresql://postgres:praison123@localhost:5432/praisonai" \
-    --knowledge-url "http://localhost:6333" \
-    --state-url "redis://localhost:6379"
-```
-
-**Expected Output:**
-```
-==================================================
-PraisonAI Persistence Doctor
-==================================================
-
-[Conversation Store] Testing: postgresql://postgres:****@localhost:5432/praisonai
-  ✅ Connected (postgres)
-
-[Knowledge Store] Testing: http://localhost:6333
-  ✅ Connected (qdrant)
-
-[State Store] Testing: redis://localhost:6379
-  ✅ Connected (redis)
-
-==================================================
-Results: 3/3 stores connected successfully
-==================================================
-```
-
-## 2. Run Command - Execute Agent with Persistence
-
-```bash
-# Run agent with persistence (dry-run first)
-praisonai persistence run \
-    --session-id "cli-demo-001" \
-    --conversation-url "postgresql://postgres:praison123@localhost:5432/praisonai" \
-    --dry-run \
-    "Hello, my name is Bob"
-
-# Actually run it
-praisonai persistence run \
-    --session-id "cli-demo-001" \
-    --conversation-url "postgresql://postgres:praison123@localhost:5432/praisonai" \
-    "Hello, my name is Bob"
-```
-
-**Expected Output:**
-```
-[Session: cli-demo-001]
-Agent: Hello Bob! Nice to meet you. How can I help you today?
-```
-
-## 3. Resume Command - Continue a Session
-
-```bash
-# Show history
-praisonai persistence resume \
-    --session-id "cli-demo-001" \
-    --conversation-url "postgresql://postgres:praison123@localhost:5432/praisonai" \
-    --show-history
-
-# Continue conversation
-praisonai persistence resume \
-    --session-id "cli-demo-001" \
-    --conversation-url "postgresql://postgres:praison123@localhost:5432/praisonai" \
-    --continue "What's my name?"
-```
-
-**Expected Output:**
-```
-[Session: cli-demo-001]
-Messages in history: 2
-
---- Conversation History ---
-[USER] Hello, my name is Bob
-[ASSISTANT] Hello Bob! Nice to meet you...
---- End History ---
-
-Agent: Your name is Bob!
-```
-
-## Environment Variables
-
-Instead of passing URLs on command line, use environment variables:
-
-```bash
-export PRAISON_CONVERSATION_URL="postgresql://postgres:praison123@localhost:5432/praisonai"
-export PRAISON_KNOWLEDGE_URL="http://localhost:6333"
-export PRAISON_STATE_URL="redis://localhost:6379"
-export OPENAI_API_KEY="your-key"
-
-# Now commands are simpler
-praisonai persistence doctor --all
-praisonai persistence run --session-id "my-session" "Hello!"
-```
-
-## Full CLI Reference
-
-```
-praisonai persistence --help
-praisonai persistence doctor --help
-praisonai persistence run --help
-praisonai persistence resume --help
-```

examples/cli/system_audit.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-# System audit: multiple command executions, report generation
-# Tests: command execution (date, disk, python, processes), file creation, file reading
-
-praisonai "Investigate my system - get the current date, check disk usage, find out what Python version is installed, list running processes sorted by memory, then write all findings to /tmp/system_audit.md as a neat report and read it back to verify" --trust

examples/cli/todo_app.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-# Todo app: multi-file app creation, execution, documentation, verification
-# Tests: multiple file creation, code execution, markdown docs, directory listing
-
-praisonai "Write a todo list app at /tmp/todo.py with functions to add, remove, and list tasks stored in /tmp/todos.json, run the script with some sample tasks added, then create documentation at /tmp/todo_docs.md explaining usage with examples, and verify all three files exist" --trust