chore: bump version to 2.2.53 and update dependencies across package files

Merge pull request #851 from MervinPraison/claude/issue-846-20250712_220811
fix: handle None response_text in Ollama sequential tool calls
2026-11-09 17:31:52 -10:00 · 2025-07-12 23:43:01 +01:00 · 2025-07-12 23:28:38 +01:00 · 2025-07-12 23:27:54 +01:00 · 2025-07-12 22:16:05 +00:00 · 2025-07-12 23:15:10 +01:00
28 changed files with 987 additions and 323 deletions
@@ -0,0 +1,81 @@
+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'
@@ -19,5 +19,5 @@ jobs:
              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 use multi agents to 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.'
+              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.'
            }) 
@@ -19,5 +19,5 @@ jobs:
              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 use multi agents to 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.'
+              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.'
            }) 
@@ -0,0 +1,69 @@
+name: Gemini Automated Issue Triage
+
+on:
+  issues:
+    types: [opened, reopened]
+
+jobs:
+  triage-issue:
+    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.
@@ -0,0 +1,200 @@
+name: Gemini Issue Review
+
+on:
+  workflow_dispatch:
+  issues:
+    types: [opened, edited]
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: read
+
+jobs:
+  review-issue:
+    if: >
+      github.event_name == 'workflow_dispatch' ||
+      github.event_name == 'issues' ||
+      (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'))
+    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 }}
+        run: |
+          # Get issue number from event or context
+          if [ "${{ github.event_name }}" = "issue_comment" ]; then
+            ISSUE_NUMBER="${{ github.event.issue.number }}"
+          elif [ "${{ github.event_name }}" = "issues" ]; then
+            ISSUE_NUMBER="${{ github.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 [ "${{ github.event_name }}" = "issue_comment" ]; then
+            COMMENT_BODY="${{ github.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 }}"
+              }
+            }
@@ -0,0 +1,204 @@
+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: Checkout PR code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate_token.outputs.token }}
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
+
+      - name: Get PR details
+        id: get_pr
+        env:
+          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            PR_NUMBER=${{ github.event.inputs.pr_number }}
+          elif [ "${{ github.event_name }}" = "issue_comment" ]; then
+            PR_NUMBER=${{ github.event.issue.number }}
+          else
+            PR_NUMBER=${{ github.event.pull_request.number }}
+          fi
+          
+          echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
+          
+          # Extract additional instructions from comment (if triggered by comment)
+          ADDITIONAL_INSTRUCTIONS=""
+          if [ "${{ github.event_name }}" = "issue_comment" ]; then
+            COMMENT_BODY="${{ github.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(cat)",
+                "run_shell_command(head)",
+                "run_shell_command(tail)",
+                "run_shell_command(grep)",
+                "run_shell_command(find)",
+                "run_shell_command(git)",
+                "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. You have access to shell commands to gather PR information and perform the review.
+
+            IMPORTANT: Use the available shell commands to gather information. Do not ask for information to be provided.
+
+            Start by running these commands to gather the required data:
+            1. Run: echo "$PR_DATA" to get PR details (JSON format)
+            2. Run: echo "$CHANGED_FILES" to get the list of changed files
+            3. Run: echo "$PR_NUMBER" to get the PR number
+            4. Run: echo "$ADDITIONAL_INSTRUCTIONS" to see any specific review instructions from the user
+            5. Run: gh pr diff $PR_NUMBER to see the full diff
+            6. For any specific files, use: cat filename, head -50 filename, or tail -50 filename
+            
+            Additional Review Instructions:
+            If ADDITIONAL_INSTRUCTIONS contains text, prioritize those specific areas or focus points in your review.
+            Common instruction examples: "focus on security", "check performance", "review error handling", "check for breaking changes"
+            
+            Once you have the information, provide a comprehensive code review by:
+            1. Writing your review to a file: write_file("review.md", "<your detailed review feedback here>")
+            2. Posting the review: gh pr comment $PR_NUMBER --body-file review.md --repo $REPOSITORY
+
+            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*
@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
    flask \
-    "praisonai>=2.2.51" \
+    "praisonai>=2.2.53" \
    "praisonai[api]" \
    gunicorn \
    markdown
@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
    praisonai_tools \
-    "praisonai>=2.2.51" \
+    "praisonai>=2.2.53" \
    "praisonai[chat]" \
    "embedchain[github,youtube]"

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

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions

 All Docker images use consistent, up-to-date versions:
- PraisonAI: `>=2.2.51`
+- PraisonAI: `>=2.2.53`
 - 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.51" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.53" "praisonaiagents==0.0.92"
 ```

 ## 🌐 Production Deployment
@@ -72,7 +72,7 @@ workflow = PraisonAIAgents(
 )

 # Run the workflow
-results = workflow.start()
+results = workflow.start(return_dict=True)

 # Print results
 print("\nWorkflow Results:")
@@ -22,9 +22,9 @@ def multiply(a: int, b: int) -> int:

 agent = Agent(
    instructions="You are a helpful assistant. You can use the tools provided to you to help the user.",
-    llm="openai/gpt-4o-mini",
+    llm="gemini/gemini-2.5-pro",
    tools=[get_stock_price, multiply]
 )

-result = agent.start("multiply the Google stock price with 2")
+result = agent.start("what is the stock price of Google? multiply the Google stock price with 2")
 print(result)
@@ -0,0 +1,30 @@
+from praisonaiagents import Agent
+
+def get_stock_price(company_name: str) -> str:
+    """
+    Get the stock price of a company
+    
+    Args:
+        company_name (str): The name of the company
+        
+    Returns:
+        str: The stock price of the company
+    """
+    return f"The stock price of {company_name} is 100"
+
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two numbers
+    """
+    return a * b
+
+
+
+agent = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user.",
+    llm="ollama/llama3.2",
+    tools=[get_stock_price, multiply]
+)
+
+result = agent.start("what is the stock price of Google? multiply the Google stock price with 2")
+print(result)
@@ -0,0 +1,30 @@
+from praisonaiagents import Agent
+
+def get_stock_price(company_name: str) -> str:
+    """
+    Get the stock price of a company
+    
+    Args:
+        company_name (str): The name of the company
+        
+    Returns:
+        str: The stock price of the company
+    """
+    return f"The stock price of {company_name} is 100"
+
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two numbers
+    """
+    return a * b
+
+
+
+agent = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user.",
+    llm="gpt-4o",
+    tools=[get_stock_price, multiply]
+)
+
+result = agent.start("what is the stock price of Google? multiply the Google stock price with 2")
+print(result)
@@ -1235,7 +1235,8 @@ Your Goal: {self.goal}"""
                    agent_role=self.role,
                    agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)],
                    execute_tool_fn=self.execute_tool,  # Pass tool execution function
-                    reasoning_steps=reasoning_steps
+                    reasoning_steps=reasoning_steps,
+                    stream=stream  # Pass the stream parameter from chat method
                    )

                    self.chat_history.append({"role": "assistant", "content": response_text})
@@ -0,0 +1,25 @@
+# Ollama Handling in LLM.py
+
+The `ollama_handled` flag is used in `llm.py` (not in `agent.py`) to track whether special Ollama model handling has been applied for tool results. Here's what I found:
+
+## Where it's used in llm.py:
+- **Line 863**: `ollama_handled = False` - initialized at the beginning of the tool execution loop
+- **Line 864**: Special handling logic via `_handle_ollama_model()` method
+- **Line 907**: `ollama_handled = True` - set when Ollama special handling is applied
+- **Line 928 & 959**: Checks `if not ollama_handled` to avoid duplicate processing
+
+## Why it's needed:
+The flag prevents duplicate processing when Ollama models require special handling. Some Ollama models return only the tool call JSON without processing the results, requiring a follow-up prompt to get the final answer. The `ollama_handled` flag ensures this special handling happens only once.
+
+## Does this contradict the requirement?
+**No, it doesn't.** The issue states:
+
+> "ollama/xxxx model is already handled via llm.py via litellm, so no special condition or handling required for ollama inside agent.py"
+
+✅ **Current implementation is correct:**
+
+- `agent.py` has NO ollama-specific conditions (only one documentation mention as an example)
+- All ollama handling is contained within `llm.py` as intended
+- The `ollama_handled` flag is an internal implementation detail within `llm.py`
+
+The codebase already follows the desired pattern where ollama models are handled through the generic LLM interface via litellm without special conditions in agent.py.
@@ -680,6 +680,7 @@ class LLM:
            max_iterations = 10  # Prevent infinite loops
            iteration_count = 0
            final_response_text = ""
+            stored_reasoning_content = None  # Store reasoning content from tool execution

            while iteration_count < max_iterations:
                try:
@@ -771,7 +772,7 @@ class LLM:
                                        if formatted_tools and self._supports_streaming_tools():
                                            tool_calls = self._process_tool_calls_from_stream(delta, tool_calls)
                            
-                            response_text = response_text.strip()
+                            response_text = response_text.strip() if response_text else "" if response_text else "" if response_text else "" if response_text else ""
                            
                            # Create a mock final_response with the captured data
                            final_response = {
@@ -857,8 +858,6 @@ class LLM:
                            iteration_count += 1
                            continue

-                        # If we reach here, no more tool calls needed - get final response
-                        # Make one more call to get the final summary response
                        # Special handling for Ollama models that don't automatically process tool results
                        ollama_handled = False
                        ollama_params = self._handle_ollama_model(response_text, tool_results, messages, original_prompt)
@@ -905,7 +904,7 @@ class LLM:
                            
                            # Set flag to indicate Ollama was handled
                            ollama_handled = True
-                            final_response_text = response_text.strip()
+                            final_response_text = response_text.strip() if response_text else ""
                            logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
                            
                            # Display the response if we got one
@@ -918,15 +917,23 @@ class LLM:
                                    console=console
                                )
                            
-                            # Return the final response after processing Ollama's follow-up
+                            # Update messages and continue the loop instead of returning
                            if final_response_text:
-                                return final_response_text
+                                # Update messages with the response to maintain conversation context
+                                messages.append({
+                                    "role": "assistant",
+                                    "content": final_response_text
+                                })
+                                # Continue the loop to check if more tools are needed
+                                iteration_count += 1
+                                continue
                            else:
                                logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
                        
-                        # If reasoning_steps is True and we haven't handled Ollama already, do a single non-streaming call
+                        # Handle reasoning_steps after tool execution if not already handled by Ollama
                        if reasoning_steps and not ollama_handled:
-                            resp = litellm.completion(
+                            # Make a non-streaming call to capture reasoning content
+                            reasoning_resp = litellm.completion(
                                **self._build_completion_params(
                                    messages=messages,
                                    temperature=temperature,
@@ -934,89 +941,28 @@ class LLM:
                                    **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                                )
                            )
-                            reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
-                            response_text = resp["choices"][0]["message"]["content"]
+                            reasoning_content = reasoning_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                            response_text = reasoning_resp["choices"][0]["message"]["content"]
                            
-                            # Optionally display reasoning if present
-                            if verbose and reasoning_content:
-                                display_interaction(
-                                    original_prompt,
-                                    f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
-                                    markdown=markdown,
-                                    generation_time=time.time() - start_time,
-                                    console=console
-                                )
-                            else:
-                                display_interaction(
-                                    original_prompt,
-                                    response_text,
-                                    markdown=markdown,
-                                    generation_time=time.time() - start_time,
-                                    console=console
-                                )
-                        
-                        # Otherwise do the existing streaming approach if not already handled
-                        elif not ollama_handled:
-                            # Get response after tool calls
-                            if stream:
-                                # Streaming approach
-                                if verbose:
-                                    with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
-                                        final_response_text = ""
-                                        for chunk in litellm.completion(
-                                            **self._build_completion_params(
-                                                messages=messages,
-                                                tools=formatted_tools,
-                                                temperature=temperature,
-                                                stream=True,
-                                                **kwargs
-                                            )
-                                        ):
-                                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                                content = chunk.choices[0].delta.content
-                                                final_response_text += content
-                                                live.update(display_generating(final_response_text, current_time))
-                                else:
-                                    final_response_text = ""
-                                    for chunk in litellm.completion(
-                                        **self._build_completion_params(
-                                            messages=messages,
-                                            tools=formatted_tools,
-                                            temperature=temperature,
-                                            stream=True,
-                                            **kwargs
-                                        )
-                                    ):
-                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            final_response_text += chunk.choices[0].delta.content
-                            else:
-                                # Non-streaming approach
-                                resp = litellm.completion(
-                                    **self._build_completion_params(
-                                        messages=messages,
-                                        tools=formatted_tools,
-                                        temperature=temperature,
-                                        stream=False,
-                                        **kwargs
-                                    )
-                                )
-                                final_response_text = resp.get("choices", [{}])[0].get("message", {}).get("content", "") or ""
+                            # Store reasoning content for later use
+                            if reasoning_content:
+                                stored_reasoning_content = reasoning_content
                            
-                            final_response_text = final_response_text.strip()
+                            # Update messages with the response
+                            messages.append({
+                                "role": "assistant",
+                                "content": response_text
+                            })
                        
-                        # Display final response
-                        if verbose:
-                            display_interaction(
-                                original_prompt,
-                                final_response_text,
-                                markdown=markdown,
-                                generation_time=time.time() - start_time,
-                                console=console
-                            )
-                        
-                        return final_response_text
+                        # After tool execution, continue the loop to check if more tools are needed
+                        # instead of immediately trying to get a final response
+                        iteration_count += 1
+                        continue
                    else:
                        # No tool calls, we're done with this iteration
+                        # If we've executed tools in previous iterations, this response contains the final answer
+                        if iteration_count > 0:
+                            final_response_text = response_text.strip() if response_text else ""
                        break
                        
                except Exception as e:
@@ -1029,15 +975,29 @@ class LLM:
            
            # No tool calls were made in this iteration, return the response
            if verbose:
-                display_interaction(
-                    original_prompt,
-                    response_text,
-                    markdown=markdown,
-                    generation_time=time.time() - start_time,
-                    console=console
-                )
+                # If we have stored reasoning content from tool execution, display it
+                if stored_reasoning_content:
+                    display_interaction(
+                        original_prompt,
+                        f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}",
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
+                else:
+                    display_interaction(
+                        original_prompt,
+                        response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
            
-            response_text = response_text.strip()
+            response_text = response_text.strip() if response_text else ""
+            
+            # Return reasoning content if reasoning_steps is True and we have it
+            if reasoning_steps and stored_reasoning_content:
+                return stored_reasoning_content
            
            # Handle output formatting
            if output_json or output_pydantic:
@@ -1053,8 +1013,8 @@ class LLM:
                    display_interaction(original_prompt, response_text, markdown=markdown,
                                     generation_time=time.time() - start_time, console=console)
                # Return reasoning content if reasoning_steps is True
-                if reasoning_steps and reasoning_content:
-                    return reasoning_content
+                if reasoning_steps and stored_reasoning_content:
+                    return stored_reasoning_content
                return response_text

            # Handle self-reflection loop
@@ -1195,7 +1155,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                            if chunk and chunk.choices and chunk.choices[0].delta.content:
                                response_text += chunk.choices[0].delta.content
                    
-                    response_text = response_text.strip()
+                    response_text = response_text.strip() if response_text else "" if response_text else ""
                    continue

                except json.JSONDecodeError:
@@ -1317,118 +1277,126 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
            # Format tools for LiteLLM using the shared helper
            formatted_tools = self._format_tools_for_litellm(tools)

-            response_text = ""
-            if reasoning_steps:
-                # Non-streaming call to capture reasoning
-                resp = await litellm.acompletion(
-                    **self._build_completion_params(
-                        messages=messages,
+            # Initialize variables for iteration loop
+            max_iterations = 10  # Prevent infinite loops
+            iteration_count = 0
+            final_response_text = ""
+            stored_reasoning_content = None  # Store reasoning content from tool execution
+
+            while iteration_count < max_iterations:
+                response_text = ""
+                reasoning_content = None
+                tool_calls = []
+                
+                if reasoning_steps and iteration_count == 0:
+                    # Non-streaming call to capture reasoning
+                    resp = await litellm.acompletion(
+                        **self._build_completion_params(
+                            messages=messages,
                        temperature=temperature,
                        stream=False,  # force non-streaming
                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                    )
-                )
-                reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
-                response_text = resp["choices"][0]["message"]["content"]
-                
-                if verbose and reasoning_content:
-                    display_interaction(
-                        "Initial reasoning:",
-                        f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
-                        markdown=markdown,
-                        generation_time=time.time() - start_time,
-                        console=console
                    )
-                elif verbose:
-                    display_interaction(
-                        "Initial response:",
-                        response_text,
-                        markdown=markdown,
-                        generation_time=time.time() - start_time,
-                        console=console
-                    )
-            else:
-                # Determine if we should use streaming based on tool support
-                use_streaming = stream
-                if formatted_tools and not self._supports_streaming_tools():
-                    # Provider doesn't support streaming with tools, use non-streaming
-                    use_streaming = False
-                
-                if use_streaming:
-                    # Streaming approach (with or without tools)
-                    tool_calls = []
+                    reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                    response_text = resp["choices"][0]["message"]["content"]
                    
-                    if verbose:
-                        async for chunk in await litellm.acompletion(
-                            **self._build_completion_params(
-                                messages=messages,
-                                temperature=temperature,
-                                stream=True,
-                                tools=formatted_tools,
-                                **kwargs
-                            )
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta:
-                                delta = chunk.choices[0].delta
-                                response_text, tool_calls = self._process_stream_delta(
-                                    delta, response_text, tool_calls, formatted_tools
-                                )
-                                if delta.content:
-                                    print("\033[K", end="\r")  
-                                    print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
-
-                    else:
-                        # Non-verbose streaming
-                        async for chunk in await litellm.acompletion(
-                            **self._build_completion_params(
-                                messages=messages,
-                                temperature=temperature,
-                                stream=True,
-                                tools=formatted_tools,
-                                **kwargs
-                            )
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta:
-                                delta = chunk.choices[0].delta
-                                if delta.content:
-                                    response_text += delta.content
-                                
-                                # Capture tool calls from streaming chunks if provider supports it
-                                if formatted_tools and self._supports_streaming_tools():
-                                    tool_calls = self._process_tool_calls_from_stream(delta, tool_calls)
-                    
-                    response_text = response_text.strip()
-                    
-                    # We already have tool_calls from streaming if supported
-                    # No need for a second API call!
-                else:
-                    # Non-streaming approach (when tools require it or streaming is disabled)
-                    tool_response = await litellm.acompletion(
-                        **self._build_completion_params(
-                            messages=messages,
-                            temperature=temperature,
-                            stream=False,
-                            tools=formatted_tools,
-                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
-                        )
-                    )
-                    response_text = tool_response.choices[0].message.get("content", "")
-                    tool_calls = tool_response.choices[0].message.get("tool_calls", [])
-                    
-                    if verbose:
-                        # Display the complete response at once
+                    if verbose and reasoning_content:
                        display_interaction(
-                            original_prompt,
+                            "Initial reasoning:",
+                            f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                    elif verbose:
+                        display_interaction(
+                            "Initial response:",
                            response_text,
                            markdown=markdown,
                            generation_time=time.time() - start_time,
                            console=console
                        )
+                else:
+                    # Determine if we should use streaming based on tool support
+                    use_streaming = stream
+                    if formatted_tools and not self._supports_streaming_tools():
+                        # Provider doesn't support streaming with tools, use non-streaming
+                        use_streaming = False
+                    
+                    if use_streaming:
+                        # Streaming approach (with or without tools)
+                        tool_calls = []
+                        
+                        if verbose:
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    tools=formatted_tools,
+                                    **kwargs
+                                )
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta:
+                                    delta = chunk.choices[0].delta
+                                    response_text, tool_calls = self._process_stream_delta(
+                                        delta, response_text, tool_calls, formatted_tools
+                                    )
+                                    if delta.content:
+                                        print("\033[K", end="\r")  
+                                        print(f"Generating... {time.time() - start_time:.1f}s", end="\r")

-            # Now handle tools if we have them (either from streaming or non-streaming)
-            if tools and execute_tool_fn and tool_calls:
-                
-                if tool_calls:
+                        else:
+                            # Non-verbose streaming
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    tools=formatted_tools,
+                                    **kwargs
+                                )
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta:
+                                    delta = chunk.choices[0].delta
+                                    if delta.content:
+                                        response_text += delta.content
+                                    
+                                    # Capture tool calls from streaming chunks if provider supports it
+                                    if formatted_tools and self._supports_streaming_tools():
+                                        tool_calls = self._process_tool_calls_from_stream(delta, tool_calls)
+                        
+                        response_text = response_text.strip() if response_text else "" if response_text else "" if response_text else ""
+                        
+                        # We already have tool_calls from streaming if supported
+                        # No need for a second API call!
+                    else:
+                        # Non-streaming approach (when tools require it or streaming is disabled)
+                        tool_response = await litellm.acompletion(
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=False,
+                                tools=formatted_tools,
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            )
+                        )
+                        response_text = tool_response.choices[0].message.get("content", "")
+                        tool_calls = tool_response.choices[0].message.get("tool_calls", [])
+                        
+                        if verbose:
+                            # Display the complete response at once
+                            display_interaction(
+                                original_prompt,
+                                response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+
+                # Now handle tools if we have them (either from streaming or non-streaming)
+                if tools and execute_tool_fn and tool_calls:
                    # Convert tool_calls to a serializable format for all providers
                    serializable_tool_calls = self._serialize_tool_calls(tool_calls)
                    messages.append({
@@ -1509,9 +1477,16 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                console=console
                            )
                        
-                        # Return the final response after processing Ollama's follow-up
+                        # Store the response for potential final return
                        if final_response_text:
-                            return final_response_text
+                            # Update messages with the response to maintain conversation context
+                            messages.append({
+                                "role": "assistant",
+                                "content": final_response_text
+                            })
+                            # Continue the loop to check if more tools are needed
+                            iteration_count += 1
+                            continue
                        else:
                            logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
                    
@@ -1576,7 +1551,28 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                if chunk and chunk.choices and chunk.choices[0].delta.content:
                                    response_text += chunk.choices[0].delta.content

-                    response_text = response_text.strip()
+                    response_text = response_text.strip() if response_text else "" if response_text else ""
+                    
+                    # After tool execution, update messages and continue the loop
+                    if response_text:
+                        messages.append({
+                            "role": "assistant",
+                            "content": response_text
+                        })
+                    
+                    # Store reasoning content if captured
+                    if reasoning_steps and reasoning_content:
+                        stored_reasoning_content = reasoning_content
+                    
+                    # Continue the loop to check if more tools are needed
+                    iteration_count += 1
+                    continue
+                else:
+                    # No tool calls, we're done with this iteration
+                    # If we've executed tools in previous iterations, this response contains the final answer
+                    if iteration_count > 0:
+                        final_response_text = response_text.strip()
+                    break

            # Handle output formatting
            if output_json or output_pydantic:
@@ -1588,13 +1584,27 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                return response_text

            if not self_reflect:
+                # Use final_response_text if we went through tool iterations
+                display_text = final_response_text if final_response_text else response_text
+                
+                # Display with stored reasoning content if available
                if verbose:
-                    display_interaction(original_prompt, response_text, markdown=markdown,
-                                     generation_time=time.time() - start_time, console=console)
-                # Return reasoning content if reasoning_steps is True
-                if reasoning_steps and reasoning_content:
-                    return reasoning_content
-                return response_text
+                    if stored_reasoning_content:
+                        display_interaction(
+                            original_prompt,
+                            f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{display_text}",
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                    else:
+                        display_interaction(original_prompt, display_text, markdown=markdown,
+                                         generation_time=time.time() - start_time, console=console)
+                
+                # Return reasoning content if reasoning_steps is True and we have it
+                if reasoning_steps and stored_reasoning_content:
+                    return stored_reasoning_content
+                return display_text

            # Handle self-reflection
            reflection_prompt = f"""
@@ -1798,7 +1808,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
            
        # Check if the response is just a JSON tool call
        try:
-            json_response = json.loads(response_text.strip())
+            json_response = json.loads(response_text.strip() if response_text else "{}")
            if not (('name' in json_response or 'function' in json_response) and 
                    not any(word in response_text.lower() for word in ['summary', 'option', 'result', 'found'])):
                return None
@@ -2056,7 +2066,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                            response_text += content
            else:
                response = litellm.completion(**completion_params)
-                response_text = response.choices[0].message.content.strip()
+                response_text = response.choices[0].message.content.strip() if response.choices[0].message.content else ""

            if verbose:
                display_interaction(
@@ -2067,7 +2077,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                    console=console or self.console
                )
            
-            return response_text.strip()
+            return response_text.strip() if response_text else ""

        except Exception as error:
            display_error(f"Error in response: {str(error)}")
@@ -2144,7 +2154,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                            response_text += content
            else:
                response = await litellm.acompletion(**completion_params)
-                response_text = response.choices[0].message.content.strip()
+                response_text = response.choices[0].message.content.strip() if response.choices[0].message.content else ""

            if verbose:
                display_interaction(
@@ -2155,7 +2165,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                    console=console or self.console
                )
            
-            return response_text.strip()
+            return response_text.strip() if response_text else ""

        except Exception as error:
            display_error(f"Error in response_async: {str(error)}")
@@ -890,45 +890,8 @@ class OpenAIClient:
                        "content": results_str
                    })
                
-                # Check if we should continue (for tools like sequential thinking)
-                should_continue = False
-                for tool_call in tool_calls:
-                    # Handle both ToolCall dataclass and OpenAI object
-                    if isinstance(tool_call, ToolCall):
-                        function_name = tool_call.function["name"]
-                        arguments = json.loads(tool_call.function["arguments"])
-                    else:
-                        function_name = tool_call.function.name
-                        arguments = json.loads(tool_call.function.arguments)
-                    
-                    # For sequential thinking tool, check if nextThoughtNeeded is True
-                    if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
-                        should_continue = True
-                        break
-                
-                if not should_continue:
-                    # Get final response after tool calls
-                    if stream:
-                        final_response = self.process_stream_response(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            tools=formatted_tools,
-                            start_time=start_time,
-                            console=console,
-                            display_fn=display_fn,
-                            reasoning_steps=reasoning_steps,
-                            **kwargs
-                        )
-                    else:
-                        final_response = self.create_completion(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            stream=False,
-                            **kwargs
-                        )
-                    break
+                # Continue the loop to allow more tool calls
+                # The model will see tool results and can make additional tool calls
                
                iteration_count += 1
            else:
@@ -1067,45 +1030,8 @@ class OpenAIClient:
                        "content": results_str
                    })
                
-                # Check if we should continue (for tools like sequential thinking)
-                should_continue = False
-                for tool_call in tool_calls:
-                    # Handle both ToolCall dataclass and OpenAI object
-                    if isinstance(tool_call, ToolCall):
-                        function_name = tool_call.function["name"]
-                        arguments = json.loads(tool_call.function["arguments"])
-                    else:
-                        function_name = tool_call.function.name
-                        arguments = json.loads(tool_call.function.arguments)
-                    
-                    # For sequential thinking tool, check if nextThoughtNeeded is True
-                    if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
-                        should_continue = True
-                        break
-                
-                if not should_continue:
-                    # Get final response after tool calls
-                    if stream:
-                        final_response = await self.process_stream_response_async(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            tools=formatted_tools,
-                            start_time=start_time,
-                            console=console,
-                            display_fn=display_fn,
-                            reasoning_steps=reasoning_steps,
-                            **kwargs
-                        )
-                    else:
-                        final_response = await self.acreate_completion(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            stream=False,
-                            **kwargs
-                        )
-                    break
+                # Continue the loop to allow more tool calls
+                # The model will see tool results and can make additional tool calls
                
                iteration_count += 1
            else:
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "praisonaiagents"
-version = "0.0.125"
+version = "0.0.127"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [
@@ -11,14 +11,30 @@ def analyze_code_changes():
    ]
    return issues[int(time.time()) % 3]

-def suggest_fixes(issue: Dict):
+def suggest_fixes(issue):
    """Simulates fix suggestions"""
    fixes = {
        "style": "Apply PEP 8 formatting",
-        "security": "Implement input validation",
+        "security": "Implement input validation", 
        "performance": "Use list comprehension"
    }
-    return fixes.get(issue["type"], "Review manually")
+    
+    # Handle both dict and string inputs
+    if isinstance(issue, dict):
+        issue_type = issue.get("type", "unknown")
+    else:
+        # If it's a string, try to extract the type
+        issue_str = str(issue).lower()
+        if "security" in issue_str:
+            issue_type = "security"
+        elif "style" in issue_str:
+            issue_type = "style"
+        elif "performance" in issue_str:
+            issue_type = "performance"
+        else:
+            issue_type = "unknown"
+    
+    return fixes.get(issue_type, "Review manually")

 def apply_automated_fix(fix: str):
    """Simulates applying automated fixes"""
@@ -98,11 +114,8 @@ def main():
    # Print results
    print("\nCode Review Results:")
    print("=" * 50)
-    for task_id, result in results["task_results"].items():
-        if result:
-            print(f"\nTask: {task_id}")
-            print(f"Result: {result.raw}")
-            print("-" * 50)
+    print(f"Results: {results}")
+    print("-" * 50)

 if __name__ == "__main__":
    main()
@@ -69,7 +69,7 @@ workflow = PraisonAIAgents(
 )

 # Run the workflow
-results = workflow.start()
+results = workflow.start(return_dict=True)

 # Print results
 print("\nWorkflow Results:")
@@ -0,0 +1,75 @@
+"""
+Test script to verify the fix for sequential tool calling.
+The agent should:
+1. Call get_stock_price to get Google's stock price (100)
+2. Call multiply to multiply 100 by 2
+3. Return the final result (200)
+"""
+
+from praisonaiagents import Agent
+
+def get_stock_price(company_name: str) -> str:
+    """
+    Get the stock price of a company
+    
+    Args:
+        company_name (str): The name of the company
+        
+    Returns:
+        str: The stock price of the company
+    """
+    print(f"[Tool Called] get_stock_price({company_name})")
+    return f"The stock price of {company_name} is 100"
+
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two numbers
+    
+    Args:
+        a (int): First number
+        b (int): Second number
+        
+    Returns:
+        int: Product of a and b
+    """
+    print(f"[Tool Called] multiply({a}, {b})")
+    return a * b
+
+# Test with Gemini
+print("=" * 60)
+print("Testing with Gemini model")
+print("=" * 60)
+
+agent_gemini = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user. When asked to multiply a stock price, first get the stock price, then multiply it.",
+    llm="gemini/gemini-2.5-pro",
+    tools=[get_stock_price, multiply],
+    verbose=True
+)
+
+result_gemini = agent_gemini.start("what is the stock price of Google? multiply the Google stock price with 2")
+print(f"\nFinal Result (Gemini): {result_gemini}")
+
+# Test with GPT-4
+print("\n" + "=" * 60)
+print("Testing with GPT-4 model")
+print("=" * 60)
+
+agent_gpt4 = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user. When asked to multiply a stock price, first get the stock price, then multiply it.",
+    llm="gpt-4o",
+    tools=[get_stock_price, multiply],
+    verbose=True
+)
+
+result_gpt4 = agent_gpt4.start("what is the stock price of Google? multiply the Google stock price with 2")
+print(f"\nFinal Result (GPT-4): {result_gpt4}")
+
+# Verify results
+print("\n" + "=" * 60)
+print("Test Results Summary")
+print("=" * 60)
+print(f"Gemini result contains '200': {'200' in str(result_gemini) if result_gemini else False}")
+print(f"GPT-4 result contains '200': {'200' in str(result_gpt4) if result_gpt4 else False}")
+print(f"Gemini returned empty: {not result_gemini or result_gemini == ''}")
+print(f"GPT-4 returned empty: {not result_gpt4 or result_gpt4 == ''}")
@@ -2375,7 +2375,7 @@ wheels = [

 [[package]]
 name = "praisonaiagents"
-version = "0.0.125"
+version = "0.0.127"
 source = { editable = "." }
 dependencies = [
    { name = "aiohttp" },
@@ -3,8 +3,8 @@ class Praisonai < Formula
  
    desc "AI tools for various AI applications"
    homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.51.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.51.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.53.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.53.tar.gz | shasum -a 256`.split.first
    license "MIT"
  
    depends_on "[email protected]"
@@ -57,7 +57,7 @@ class CloudDeployer:
            file.write("FROM python:3.11-slim\n")
            file.write("WORKDIR /app\n")
            file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.2.51 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.53 gunicorn markdown\n")
            file.write("EXPOSE 8080\n")
            file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
            
@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.51"
+version = "2.2.53"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
    "rich>=13.7",
    "markdown>=3.5",
    "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.125",
+    "praisonaiagents>=0.0.127",
    "python-dotenv>=0.19.0",
    "instructor>=1.3.3",
    "PyYAML>=6.0",
@@ -95,7 +95,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]

 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.51"
+version = "2.2.53"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -113,7 +113,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.125"
+praisonaiagents = ">=0.0.127"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"
@@ -3931,7 +3931,7 @@ wheels = [

 [[package]]
 name = "praisonai"
-version = "2.2.51"
+version = "2.2.53"
 source = { editable = "." }
 dependencies = [
    { name = "instructor" },
@@ -4073,7 +4073,7 @@ requires-dist = [
    { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
    { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.15" },
    { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.15" },
-    { name = "praisonaiagents", specifier = ">=0.0.125" },
+    { name = "praisonaiagents", specifier = ">=0.0.127" },
    { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
    { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
    { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4130,7 +4130,7 @@ wheels = [

 [[package]]
 name = "praisonaiagents"
-version = "0.0.125"
+version = "0.0.127"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "aiohttp" },
@@ -4140,9 +4140,9 @@ dependencies = [
    { name = "pydantic" },
    { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ed/e8/bed80966c49482a565e9e6a7eab93ea81ce5381d3f20b60f550c3624fbcb/praisonaiagents-0.0.125.tar.gz", hash = "sha256:a5ec4da7e3a948303038f0a56f1863add3183af8b415e587e007895ce752615a", size = 185807 }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/4d/88b4292c5c1260bf916e94d20a1496b67b6a7e5f5bd6a19fe714c371a82e/praisonaiagents-0.0.127.tar.gz", hash = "sha256:95964189509c012c64841d71548337c9f560afda4e7a395744c3f90dda085aaa", size = 186285 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/0c/6072b7e5e5eb489279381cd6d18f200916905fa731d0cc4318ac514f2152/praisonaiagents-0.0.125-py3-none-any.whl", hash = "sha256:fff3f92103d9801da517f4b253d86e76afbfee566e632e12792cd22d583223d9", size = 207023 },
+    { url = "https://files.pythonhosted.org/packages/6a/46/6cc85f5e0e9b29960226bec79d2eefde553cc9d322cfa025a5982e92f633/praisonaiagents-0.0.127-py3-none-any.whl", hash = "sha256:4f09dd093d17de12d16b48b95363f5d87b7ef755c48bf3a605f1e8457d33bce3", size = 206871 },
 ]

 [[package]]
Author	SHA1	Message	Date
Mervin Praison	bbc4530329	chore: bump version to 2.2.53 and update dependencies across package files	2025-07-12 23:43:01 +01:00
Mervin Praison	aab975bec7	Merge pull request #851 from MervinPraison/claude/issue-846-20250712_220811 fix: handle None response_text in Ollama sequential tool calls	2025-07-12 23:28:38 +01:00
Mervin Praison	50c50fa567	Merge pull request #849 from MervinPraison/claude/issue-845-20250712_183232 fix: enable sequential tool execution in OpenAI client	2025-07-12 23:27:54 +01:00
claude[bot]andMervin Praison	68f280634a	refactor: remove dead code from sequential tool execution logic - Remove unused should_continue variable and related logic - Simplify code by removing special handling for sequentialthinking tool - Add clear comments explaining the sequential execution behavior Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 22:16:05 +00:00
Mervin Praison	346488fbec	Delete test_sequential_fix.py	2025-07-12 23:15:10 +01:00
claude[bot]andMervin Praison	57b5a1fd8d	fix: handle None response_text in Ollama sequential tool calls - Add None checks before calling .strip() on response_text - Fixes 'NoneType' object has no attribute 'strip' error with Ollama models - Applied pattern: response_text.strip() if response_text else "" - Fixed 14 locations where .strip() was called without None checks - Ensures backward compatibility by returning empty string instead of None Fixes issue #846 Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 22:11:55 +00:00
claude[bot]andMervin Praison	d75a5bb728	test: add assertions to test_sequential_fix.py for automated testing - Add proper assertions to verify sequential tool execution results - Improve multiply function docstring with complete Args and Returns sections - Add success message when all assertions pass Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 22:10:09 +00:00
Mervin Praison	519ecc025a	feat: update allowed commands in GitHub workflow files for Gemini reviews	2025-07-12 21:21:23 +01:00
Mervin Praison	8290b95132	refactor: update issue review prompt with clearer instructions and dynamic commands	2025-07-12 21:01:13 +01:00
Mervin Praison	3d95e1ff0e	feat: add read_file permission to Gemini PR review workflow	2025-07-12 20:55:41 +01:00
Mervin Praison	74405d1bbe	feat: add read_file permission to Gemini issue review workflow	2025-07-12 20:54:59 +01:00
Mervin Praison	d307c3857c	feat: add environment variables for Gemini CLI action in GitHub workflow	2025-07-12 20:54:31 +01:00
Mervin Praison	fbe5dddaae	chore: disable telemetry in GitHub workflow configurations	2025-07-12 20:45:20 +01:00
Mervin Praison	7e4108918d	fix: move GH_TOKEN to local env scope in GitHub workflow	2025-07-12 20:40:04 +01:00
Mervin Praison	da7e38100e	feat: add GitHub workflow for automated issue review using Gemini AI	2025-07-12 20:36:37 +01:00
Mervin Praison	848459b816	feat: add edit, web-fetch, web-search and memoryTool permissions while removing telemetry setup	2025-07-12 20:35:19 +01:00
Mervin Praison	cd63845398	feat: add git command to allowed shell commands in PR review workflow	2025-07-12 20:31:18 +01:00
Mervin Praison	7827427dc0	feat: move Gemini PR review action to dedicated directory with configuration	2025-07-12 20:16:47 +01:00
Mervin Praison	0e378d0754	feat: add GitHub workflows for Gemini issue triage and PR review automation	2025-07-12 20:03:05 +01:00
Mervin Praison	206022eb9c	refactor: simplify auto-comment workflows by removing multi-agent review requirement	2025-07-12 19:48:23 +01:00
Mervin Praison	901ba8074d	Delete test_sequential_fix.py	2025-07-12 19:40:42 +01:00
claude[bot]andMervin Praison	953ee6e7bd	fix: enable sequential tool execution in OpenAI client Removes premature loop termination after tool execution to allow sequential tool calls. The model can now see tool results and make additional tool calls as needed. Fixes #845 Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 18:36:00 +00:00
Mervin Praison	181d7e1ede	feat: bump PraisonAI to v2.2.52 and add sequential agent examples for OpenAI/Ollama	2025-07-12 19:12:05 +01:00
Mervin Praison	4039878422	Merge pull request #842 from MervinPraison/claude/issue-839-20250712_075350 fix: allow agents to continue with sequential tool calls	2025-07-12 19:04:25 +01:00
Mervin Praison	461eba18d5	Delete src/praisonai/tests/unit/test_sequential_tool_calling.py	2025-07-12 19:03:44 +01:00
claude[bot]andMervin Praison	331a1de610	test: add comprehensive test suite for sequential tool calling This test file validates the fix for issue #839, ensuring agents can: - Execute multiple tools in sequence - Pass results between tool calls - Return final combined results without empty responses Tests include: - Sequential execution of 2 and 3 tools - Multiple agents with sequential tools - Mocked LLM responses - Edge case prevention for empty responses Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 18:00:27 +00:00
claude[bot]andMervin Praison	91632eb5e4	fix: correct Ollama return statement and variable reference for sequential tool calling - Replace early return with loop continuation in Ollama handling to match async behavior - Fix variable reference from reasoning_content to stored_reasoning_content - Ensures agents can perform sequential tool calls as intended Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 17:54:53 +00:00
Mervin Praison	ad46225483	Rename src/praisonai/tests/unit/test_fix_comprehensive.py to src/praisonai-agents/tests/test_fix_comprehensive.py	2025-07-12 18:50:30 +01:00
Mervin Praison	9af6758eb6	Delete test_fix.py	2025-07-12 18:48:37 +01:00
Mervin Praison	aac67a6572	Rename test_fix_comprehensive.py to src/praisonai/tests/unit/test_fix_comprehensive.py	2025-07-12 18:47:35 +01:00
claude[bot]andMervin Praison	2ceff9bfae	fix: correct indentation error in async streaming code Fixed SyntaxError caused by incorrect indentation in the async version of get_response_async method. The if/else blocks for streaming vs non-streaming approaches now have proper indentation. Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 17:41:09 +00:00
claude[bot]andMervin Praison	3b7af02bea	fix: correct indentation error in async streaming code Fixed IndentationError at line 1325 where the async for loop was not properly indented under the if verbose: block. Also corrected the indentation of the else block for non-verbose streaming. Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 17:33:23 +00:00
Mervin Praison	1ee7cfa2ef	Merge pull request #844 from MervinPraison/claude/issue-840-20250712_172354 docs: add OLLAMA_HANDLING.md to explain ollama_handled flag usage	2025-07-12 18:32:16 +01:00
claude[bot]andMervin Praison	b01bd41574	fix: add sequential tool calling support to async get_response_async method - Add while loop structure with max_iterations and iteration_count - Replace return statements with loop continuation after tool execution - Store reasoning content across iterations for proper display - Update final response handling to use stored values from iterations - Ensure async behavior matches sync version for issue #839 This resolves the inconsistency where async agents would return empty responses after first tool call instead of continuing with additional required tool calls. Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 17:27:37 +00:00
claude[bot]andMervin Praison	6570e445b8	docs: add OLLAMA_HANDLING.md to explain ollama_handled flag usage Add documentation to clarify that ollama handling is correctly implemented in llm.py and not in agent.py, addressing issue #840 Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 17:25:07 +00:00
Mervin Praison	b421bcf925	Merge pull request #843 from MervinPraison/claude/issue-841-20250712_080725 fix: add return_dict=True to fix TypeError in prompt_chaining tests	2025-07-12 18:24:24 +01:00
claude[bot]andMervin Praison	41d0998b76	fix: preserve reasoning_steps functionality with sequential tool calling - Add stored_reasoning_content to capture reasoning after tool execution - Restore reasoning_steps handling after tools while keeping loop continuation - Update final response display to include stored reasoning when available - Return reasoning content when reasoning_steps=True and content exists This ensures backward compatibility while maintaining the sequential tool calling fix Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 08:41:06 +00:00
claude[bot]andMervin Praison	393e0ee33d	fix: document async limitation and ensure consistent behavior - Added clear documentation that async version doesn't support sequential tool calling - Reverted incomplete async implementation to avoid breaking existing functionality - Sync version retains the fix for sequential tool calling (issue #839) - Created a known limitation that needs to be addressed in a future PR Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 08:40:25 +00:00
claude[bot]andMervin Praison	0dce4de4a4	fix: add return_dict=True to fix TypeError in prompt_chaining tests The workflow.start() method returns a string by default (for backward compatibility), but the test files were expecting a dictionary. Fixed by adding return_dict=True parameter to get the expected dictionary format with task_results and task_status keys. Fixes #841 Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 08:23:56 +00:00
Mervin Praison	7fe4b48c6e	fix: update LLM model and refine agent instruction Changed the LLM model from "openai/gpt-4o-mini" to "gemini/gemini-2.5-pro" for improved performance. Updated the agent's instruction to provide clearer context for the task, enhancing user interaction. Also, optimised the suggest_fixes function to handle both dictionary and string inputs, improving its flexibility in suggesting fixes based on issue type. This minimal change aims to enhance the functionality while maintaining existing code integrity.	2025-07-12 09:22:33 +01:00
claude[bot]andMervin Praison	5286912f34	test: add test scripts for sequential tool calling fix Add test scripts to verify the fix for issue #839 works correctly with both Gemini and GPT-4 models. Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 08:01:18 +00:00
claude[bot]andMervin Praison	d6cb1c0165	fix: allow agents to continue with sequential tool calls After executing tool calls, the agent now continues the iteration loop instead of immediately trying to get a final response. This allows the LLM to decide if more tools are needed to complete the task. Fixes issue where agents would return empty responses after the first tool call instead of continuing with additional required tool calls. Resolves #839 Co-authored-by: Mervin Praison <[email protected]>	2025-07-12 08:01:10 +00:00
Mervin Praison	08ed3f94dc	Merge pull request #836 from MervinPraison/claude/issue-835-20250711_234446 fix: capture final response after tool execution in LLM	2025-07-12 01:10:32 +01:00
Mervin Praison	d3bfbc4b92	Delete test_issue_835.py	2025-07-12 01:00:19 +01:00
claude[bot]andMervin Praison	af7081d294	fix: capture final response after tool execution in LLM When an agent executes tools and the final iteration contains the answer without additional tool calls, ensure the response text is properly captured and returned instead of returning empty/None. This fixes the issue where agents with multiple tools would return empty responses after successfully executing tools. Fixes #835 Co-authored-by: Mervin Praison <[email protected]>	2025-07-11 23:52:25 +00:00
Mervin Praison	3b2f26699e	Merge pull request #834 from MervinPraison/claude/pr-832-20250711_232348 PR #832: Changes from Claude	2025-07-12 00:42:58 +01:00
claude[bot]andMervin Praison	7aa61b9155	fix: pass stream parameter from Agent to LLM The Agent class was not passing the stream parameter to the LLM's get_response() method, causing the LLM to always use its default stream=True behavior regardless of the Agent's configuration. This fix ensures that when an Agent is created with stream=False or when chat() is called with stream=False, this preference is properly passed to the LLM. Co-authored-by: Mervin Praison <[email protected]>	2025-07-11 23:31:50 +00:00