Merge main into neubig/refactor-bash-command-processing (keeping our poetry.lock)

Co-authored-by: Robert Brennan <accounts@rbren.io>

.github/ISSUE_TEMPLATE/bug_template.yml

@@ -30,6 +30,7 @@ body:
       description: How are you running OpenHands?
       options:
         - Docker command in README
+        - GitHub resolver
         - Development workflow
         - app.all-hands.dev
         - Other

.github/dependabot.yml

@@ -10,12 +10,6 @@ updates:
       pre-commit:
         patterns:
           - "pre-commit"
-      llama:
-        patterns:
-          - "llama*"
-      chromadb:
-        patterns:
-          - "chromadb"
       browsergym:
         patterns:
           - "browsergym*"

.github/pull_request_template.md

@@ -1,11 +1,12 @@
-**End-user friendly description of the problem this fixes or functionality that this introduces**
-
-- [ ] Include this change in the Release Notes. If checked, you must provide an **end-user friendly** description for your change below
-
----
-**Give a summary of what the PR does, explaining any non-trivial design decisions**
+- [ ] This change is worth documenting at https://docs.all-hands.dev/
+- [ ] Include this change in the Release Notes. If checked, you **must** provide an **end-user friendly** description for your change below
 
+**End-user friendly description of the problem this fixes or functionality that this introduces.**
 
 
 ---
-**Link of any specific issues this addresses**
+**Give a summary of what the PR does, explaining any non-trivial design decisions.**
+
+
+---
+**Link of any specific issues this addresses.**

.github/workflows/clean-up.yml

@@ -46,7 +46,7 @@ on:
 
 jobs:
   del_runs:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     permissions:
       actions: write
       contents: read

.github/workflows/deploy-docs.yml

@@ -24,22 +24,20 @@ jobs:
   build:
     if: github.repository == 'All-Hands-AI/OpenHands'
     name: Build Docusaurus
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: actions/setup-node@v4
+      - uses: useblacksmith/setup-node@v5
         with:
           node-version: 18
           cache: npm
           cache-dependency-path: docs/package-lock.json
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: '3.12'
-      - name: Generate Python Docs
-        run: rm -rf docs/modules/python && pip install pydoc-markdown && pydoc-markdown
       - name: Install dependencies
         run: cd docs && npm ci
       - name: Build website
@@ -54,7 +52,7 @@ jobs:
   deploy:
     if: github.ref == 'refs/heads/main' && github.repository == 'All-Hands-AI/OpenHands'
     name: Deploy to GitHub Pages
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     # This job only runs on "main" so only run one of these jobs at a time
     # otherwise it will fail if one is already running
     concurrency:

.github/workflows/dummy-agent-test.yml

@@ -16,37 +16,27 @@ concurrency:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: true
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: false
-          swap-storage: true
       - name: Set up Docker Buildx
         id: buildx
         uses: docker/setup-buildx-action@v3
       - name: Install tmux
         run: sudo apt-get update && sudo apt-get install -y tmux
+      - name: Setup Node.js
+        uses: useblacksmith/setup-node@v5
+        with:
+          node-version: '22.x'
       - name: Install poetry via pipx
         run: pipx install poetry
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: '3.12'
           cache: 'poetry'
       - name: Install Python dependencies using Poetry
-        run: poetry install --without evaluation,llama-index
+        run: poetry install --without evaluation
       - name: Build Environment
         run: make build
       - name: Run tests

.github/workflows/eval-runner.yml

@@ -1,139 +0,0 @@
-name: Run SWE-Bench Evaluation
-
-on:
-  pull_request:
-    types: [labeled]
-  workflow_dispatch:
-    inputs:
-      reason:
-        description: "Reason for manual trigger"
-        required: true
-        default: ""
-
-env:
-  N_PROCESSES: 32 # Global configuration for number of parallel processes for evaluation
-
-jobs:
-  run-evaluation:
-    if: github.event.label.name == 'eval-this' || github.event_name != 'pull_request'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: "read"
-      id-token: "write"
-      pull-requests: "write"
-      issues: "write"
-    strategy:
-      matrix:
-        python-version: ["3.12"]
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install tmux
-        run: sudo apt-get update && sudo apt-get install -y tmux
-      - name: Install poetry via pipx
-        run: pipx install poetry
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: "poetry"
-
-      - name: Comment on PR if 'eval-this' label is present
-        if: github.event_name == 'pull_request' && github.event.label.name == 'eval-this'
-        uses: KeisukeYamashita/create-comment@v1
-        with:
-          unique: false
-          comment: |
-            Hi! I started running the evaluation on your PR. You will receive a comment with the results shortly.
-
-      - name: Install Python dependencies using Poetry
-        run: poetry install
-
-      - name: Configure config.toml for evaluation
-        env:
-          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_LLM_API_KEY }}
-        run: |
-          echo "[llm.eval]" > config.toml
-          echo "model = \"deepseek/deepseek-chat\"" >> config.toml
-          echo "api_key = \"$DEEPSEEK_API_KEY\"" >> config.toml
-          echo "temperature = 0.0" >> config.toml
-
-      - name: Run SWE-Bench evaluation
-        env:
-          ALLHANDS_API_KEY: ${{ secrets.ALLHANDS_EVAL_RUNTIME_API_KEY }}
-          RUNTIME: remote
-          SANDBOX_REMOTE_RUNTIME_API_URL: https://runtime.eval.all-hands.dev
-          EVAL_DOCKER_IMAGE_PREFIX: us-central1-docker.pkg.dev/evaluation-092424/swe-bench-images
-
-        run: |
-          poetry run ./evaluation/benchmarks/swe_bench/scripts/run_infer.sh llm.eval HEAD CodeActAgent 300 30 $N_PROCESSES "princeton-nlp/SWE-bench_Lite" test
-          OUTPUT_FOLDER=$(find evaluation/evaluation_outputs/outputs/princeton-nlp__SWE-bench_Lite-test/CodeActAgent -name "deepseek-chat_maxiter_50_N_*-no-hint-run_1" -type d | head -n 1)
-          echo "OUTPUT_FOLDER for SWE-bench evaluation: $OUTPUT_FOLDER"
-          poetry run ./evaluation/benchmarks/swe_bench/scripts/eval_infer_remote.sh $OUTPUT_FOLDER/output.jsonl $N_PROCESSES "princeton-nlp/SWE-bench_Lite" test
-
-          poetry run ./evaluation/benchmarks/swe_bench/scripts/eval/summarize_outputs.py $OUTPUT_FOLDER/output.jsonl > summarize_outputs.log 2>&1
-          echo "SWEBENCH_REPORT<<EOF" >> $GITHUB_ENV
-          cat summarize_outputs.log >> $GITHUB_ENV
-          echo "EOF" >> $GITHUB_ENV
-
-      - name: Create tar.gz of evaluation outputs
-        run: |
-          TIMESTAMP=$(date +'%y-%m-%d-%H-%M')
-          tar -czvf evaluation_outputs_${TIMESTAMP}.tar.gz evaluation/evaluation_outputs/outputs
-
-      - name: Upload evaluation results as artifact
-        uses: actions/upload-artifact@v4
-        id: upload_results_artifact
-        with:
-          name: evaluation-outputs
-          path: evaluation_outputs_*.tar.gz
-
-      - name: Get artifact URL
-        run: echo "ARTIFACT_URL=${{ steps.upload_results_artifact.outputs.artifact-url }}" >> $GITHUB_ENV
-
-      - name: Authenticate to Google Cloud
-        uses: 'google-github-actions/auth@v2'
-        with:
-          credentials_json: ${{ secrets.GCP_RESEARCH_OBJECT_CREATOR_SA_KEY }}
-
-      - name: Set timestamp and trigger reason
-        run: |
-          echo "TIMESTAMP=$(date +'%Y-%m-%d-%H-%M')" >> $GITHUB_ENV
-          if [[ "${{ github.event_name }}" == "pull_request" ]]; then
-            echo "TRIGGER_REASON=pr-${{ github.event.pull_request.number }}" >> $GITHUB_ENV
-          elif [[ "${{ github.event_name }}" == "schedule" ]]; then
-            echo "TRIGGER_REASON=schedule" >> $GITHUB_ENV
-          else
-            echo "TRIGGER_REASON=manual-${{ github.event.inputs.reason }}" >> $GITHUB_ENV
-          fi
-
-      - name: Upload evaluation results to Google Cloud Storage
-        uses: 'google-github-actions/upload-cloud-storage@v2'
-        with:
-          path: 'evaluation/evaluation_outputs/outputs'
-          destination: 'openhands-oss-eval-results/${{ env.TIMESTAMP }}-${{ env.TRIGGER_REASON }}'
-
-      - name: Comment with evaluation results and artifact link
-        id: create_comment
-        uses: KeisukeYamashita/create-comment@v1
-        with:
-          number: ${{ github.event_name == 'pull_request' && github.event.pull_request.number || 4504 }}
-          unique: false
-          comment: |
-              Trigger by: ${{ github.event_name == 'pull_request' && format('Pull Request (eval-this label on PR #{0})', github.event.pull_request.number) || github.event_name == 'schedule' && 'Daily Schedule' || format('Manual Trigger: {0}', github.event.inputs.reason) }}
-              Commit: ${{ github.sha }}
-              **SWE-Bench Evaluation Report**
-              ${{ env.SWEBENCH_REPORT }}
-              ---
-              You can download the full evaluation outputs [here](${{ env.ARTIFACT_URL }}).
-
-      - name: Post to a Slack channel
-        id: slack
-        uses: slackapi/slack-github-action@v2.0.0
-        with:
-          channel-id: 'C07SVQSCR6F'
-          slack-message: "*Evaluation Trigger:* ${{ github.event_name == 'pull_request' && format('Pull Request (eval-this label on PR #{0})', github.event.pull_request.number) || github.event_name == 'schedule' && 'Daily Schedule' || format('Manual Trigger: {0}', github.event.inputs.reason) }}\n\nLink to summary: [here](https://github.com/${{ github.repository }}/issues/${{ github.event_name == 'pull_request' && github.event.pull_request.number || 4504 }}#issuecomment-${{ steps.create_comment.outputs.comment-id }})"
-        env:
-          SLACK_BOT_TOKEN: ${{ secrets.EVAL_NOTIF_SLACK_BOT_TOKEN }}

.github/workflows/fe-unit-tests.yml

@@ -21,7 +21,7 @@ jobs:
   # Run frontend unit tests
   fe-test:
     name: FE Unit Tests
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     strategy:
       matrix:
         node-version: [20, 22]
@@ -30,7 +30,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: useblacksmith/setup-node@v5
         with:
           node-version: ${{ matrix.node-version }}
       - name: Install dependencies

.github/workflows/ghcr-build.yml

@@ -32,7 +32,7 @@ jobs:
   # Builds the OpenHands Docker images
   ghcr_build_app:
     name: Build App Image
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     permissions:
       contents: read
       packages: write
@@ -41,22 +41,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
         with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: true
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: false
-          swap-storage: true
+          ref: ${{ github.event.pull_request.head.sha }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.3.0
+        uses: docker/setup-qemu-action@v3.6.0
         with:
           image: tonistiigi/binfmt:latest
       - name: Login to GHCR
@@ -68,22 +56,22 @@ jobs:
       - name: Set up Docker Buildx
         id: buildx
         uses: docker/setup-buildx-action@v3
+      - name: Lowercase Repository Owner
+        run: |
+          echo REPO_OWNER=$(echo ${{ github.repository_owner }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
       - name: Build and push app image
         if: "!github.event.pull_request.head.repo.fork"
         run: |
-          ./containers/build.sh -i openhands -o ${{ github.repository_owner }} --push
+          ./containers/build.sh -i openhands -o ${{ env.REPO_OWNER }} --push
       - name: Build app image
         if: "github.event.pull_request.head.repo.fork"
         run: |
-          ./containers/build.sh -i openhands -o ${{ github.repository_owner }} --load
+          ./containers/build.sh -i openhands -o ${{ env.REPO_OWNER }} --load
       - name: Get hash in App Image
         id: get_hash_in_app_image
         run: |
-          # Lowercase the repository owner
-          export REPO_OWNER=${{ github.repository_owner }}
-          REPO_OWNER=$(echo $REPO_OWNER | tr '[:upper:]' '[:lower:]')
           # Run the build script in the app image
-          docker run -e SANDBOX_USER_ID=0 -v /var/run/docker.sock:/var/run/docker.sock ghcr.io/${REPO_OWNER}/openhands:${{ env.RELEVANT_SHA }} /bin/bash -c "mkdir -p containers/runtime; python3 openhands/runtime/utils/runtime_build.py --base_image ${{ env.BASE_IMAGE_FOR_HASH_EQUIVALENCE_TEST }} --build_folder containers/runtime --force_rebuild" 2>&1 | tee docker-outputs.txt
+          docker run -e SANDBOX_USER_ID=0 -v /var/run/docker.sock:/var/run/docker.sock ghcr.io/${{ env.REPO_OWNER }}/openhands:${{ env.RELEVANT_SHA }} /bin/bash -c "mkdir -p containers/runtime; python3 openhands/runtime/utils/runtime_build.py --base_image ${{ env.BASE_IMAGE_FOR_HASH_EQUIVALENCE_TEST }} --build_folder containers/runtime --force_rebuild" 2>&1 | tee docker-outputs.txt
           # Get the hash from the build script
           hash_from_app_image=$(cat docker-outputs.txt | grep "Hash for docker build directory" | awk -F "): " '{print $2}' | uniq | head -n1)
           echo "hash_from_app_image=$hash_from_app_image" >> $GITHUB_OUTPUT
@@ -92,7 +80,7 @@ jobs:
   # Builds the runtime Docker images
   ghcr_build_runtime:
     name: Build Image
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     permissions:
       contents: read
       packages: write
@@ -104,22 +92,10 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
         with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: true
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: false
-          swap-storage: true
+          ref: ${{ github.event.pull_request.head.sha }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3.3.0
+        uses: docker/setup-qemu-action@v3.6.0
         with:
           image: tonistiigi/binfmt:latest
       - name: Login to GHCR
@@ -132,11 +108,11 @@ jobs:
         id: buildx
         uses: docker/setup-buildx-action@v3
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: '3.12'
       - name: Cache Poetry dependencies
-        uses: actions/cache@v4
+        uses: useblacksmith/cache@v5
         with:
           path: |
             ~/.cache/pypoetry
@@ -150,16 +126,19 @@ jobs:
         run: make install-python-dependencies
       - name: Create source distribution and Dockerfile
         run: poetry run python3 openhands/runtime/utils/runtime_build.py --base_image ${{ matrix.base_image.image }} --build_folder containers/runtime --force_rebuild
+      - name: Lowercase Repository Owner
+        run: |
+          echo REPO_OWNER=$(echo ${{ github.repository_owner }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
       - name: Build and push runtime image ${{ matrix.base_image.image }}
         if: github.event.pull_request.head.repo.fork != true
         run: |
-          ./containers/build.sh -i runtime -o ${{ github.repository_owner }} --push -t ${{ matrix.base_image.tag }}
+          ./containers/build.sh -i runtime -o ${{ env.REPO_OWNER }} --push -t ${{ matrix.base_image.tag }}
       # Forked repos can't push to GHCR, so we need to upload the image as an artifact
       - name: Build runtime image ${{ matrix.base_image.image }} for fork
         if: github.event.pull_request.head.repo.fork
         uses: docker/build-push-action@v6
         with:
-          tags: ghcr.io/all-hands-ai/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image.tag }}
+          tags: ghcr.io/${{ env.REPO_OWNER }}/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image.tag }}
           outputs: type=docker,dest=/tmp/runtime-${{ matrix.base_image.tag }}.tar
           context: containers/runtime
       - name: Upload runtime image for fork
@@ -171,7 +150,7 @@ jobs:
 
   verify_hash_equivalence_in_runtime_and_app:
     name: Verify Hash Equivalence in Runtime and Docker images
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     needs: [ghcr_build_runtime, ghcr_build_app]
     strategy:
       fail-fast: false
@@ -179,8 +158,10 @@ jobs:
         base_image: ['nikolaik']
     steps:
       - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
       - name: Cache Poetry dependencies
-        uses: actions/cache@v4
+        uses: useblacksmith/cache@v5
         with:
           path: |
             ~/.cache/pypoetry
@@ -189,7 +170,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-poetry-
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: '3.12'
       - name: Install poetry via pipx
@@ -219,31 +200,17 @@ jobs:
             exit 1
           fi
 
-  # Run unit tests with the EventStream runtime Docker images as root
+  # Run unit tests with the Docker runtime Docker images as root
   test_runtime_root:
     name: RT Unit Tests (Root)
     needs: [ghcr_build_runtime]
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     strategy:
       fail-fast: false
       matrix:
         base_image: ['nikolaik']
     steps:
       - uses: actions/checkout@v4
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: true
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: false
-          swap-storage: true
       - name: Set up Docker Buildx
         id: buildx
         uses: docker/setup-buildx-action@v3
@@ -259,7 +226,7 @@ jobs:
         run: |
           docker load --input /tmp/runtime-${{ matrix.base_image }}.tar
       - name: Cache Poetry dependencies
-        uses: actions/cache@v4
+        uses: useblacksmith/cache@v5
         with:
           path: |
             ~/.cache/pypoetry
@@ -268,14 +235,17 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-poetry-
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: '3.12'
       - name: Install poetry via pipx
         run: pipx install poetry
       - name: Install Python dependencies using Poetry
         run: make install-python-dependencies
-      - name: Run runtime tests
+      - name: Lowercase Repository Owner
+        run: |
+          echo REPO_OWNER=$(echo ${{ github.repository_owner }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+      - name: Run docker runtime tests
         run: |
           # We install pytest-xdist in order to run tests across CPUs
           poetry run pip install pytest-xdist
@@ -283,10 +253,9 @@ jobs:
           # Install to be able to retry on failures for flaky tests
           poetry run pip install pytest-rerunfailures
 
-          image_name=ghcr.io/${{ github.repository_owner }}/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image }}
-          image_name=$(echo $image_name | tr '[:upper:]' '[:lower:]')
+          image_name=ghcr.io/${{ env.REPO_OWNER }}/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image }}
 
-          TEST_RUNTIME=eventstream \
+          TEST_RUNTIME=docker \
           SANDBOX_USER_ID=$(id -u) \
           SANDBOX_RUNTIME_CONTAINER_IMAGE=$image_name \
           TEST_IN_CI=true \
@@ -297,30 +266,16 @@ jobs:
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-  # Run unit tests with the EventStream runtime Docker images as openhands user
+  # Run unit tests with the Docker runtime Docker images as openhands user
   test_runtime_oh:
     name: RT Unit Tests (openhands)
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     needs: [ghcr_build_runtime]
     strategy:
       matrix:
         base_image: ['nikolaik']
     steps:
       - uses: actions/checkout@v4
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          # this might remove tools that are actually needed,
-          # if set to "true" but frees about 6 GB
-          tool-cache: true
-          # all of these default to true, but feel free to set to
-          # "false" if necessary for your workflow
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: false
-          swap-storage: true
       - name: Set up Docker Buildx
         id: buildx
         uses: docker/setup-buildx-action@v3
@@ -336,7 +291,7 @@ jobs:
         run: |
           docker load --input /tmp/runtime-${{ matrix.base_image }}.tar
       - name: Cache Poetry dependencies
-        uses: actions/cache@v4
+        uses: useblacksmith/cache@v5
         with:
           path: |
             ~/.cache/pypoetry
@@ -345,13 +300,16 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-poetry-
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: '3.12'
       - name: Install poetry via pipx
         run: pipx install poetry
       - name: Install Python dependencies using Poetry
         run: make install-python-dependencies
+      - name: Lowercase Repository Owner
+        run: |
+          echo REPO_OWNER=$(echo ${{ github.repository_owner }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
       - name: Run runtime tests
         run: |
           # We install pytest-xdist in order to run tests across CPUs
@@ -360,10 +318,9 @@ jobs:
           # Install to be able to retry on failures for flaky tests
           poetry run pip install pytest-rerunfailures
 
-          image_name=ghcr.io/${{ github.repository_owner }}/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image }}
-          image_name=$(echo $image_name | tr '[:upper:]' '[:lower:]')
+          image_name=ghcr.io/${{ env.REPO_OWNER }}/runtime:${{ env.RELEVANT_SHA }}-${{ matrix.base_image }}
 
-          TEST_RUNTIME=eventstream \
+          TEST_RUNTIME=docker \
           SANDBOX_USER_ID=$(id -u) \
           SANDBOX_RUNTIME_CONTAINER_IMAGE=$image_name \
           TEST_IN_CI=true \
@@ -381,7 +338,7 @@ jobs:
   runtime_tests_check_success:
     name: All Runtime Tests Passed
     if: ${{ !cancelled() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     needs: [test_runtime_root, test_runtime_oh, verify_hash_equivalence_in_runtime_and_app]
     steps:
       - name: All tests passed
@@ -390,7 +347,7 @@ jobs:
   runtime_tests_check_fail:
     name: All Runtime Tests Passed
     if: ${{ cancelled() || contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     needs: [test_runtime_root, test_runtime_oh, verify_hash_equivalence_in_runtime_and_app]
     steps:
       - name: Some tests failed
@@ -401,7 +358,7 @@ jobs:
     name: Update PR Description
     if: github.event_name == 'pull_request' && !github.event.pull_request.head.repo.fork && github.actor != 'dependabot[bot]'
     needs: [ghcr_build_runtime]
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/integration-runner.yml

@@ -18,7 +18,7 @@ env:
 jobs:
   run-integration-tests:
     if: github.event.label.name == 'integration-test' || github.event_name == 'workflow_dispatch' || github.event_name == 'schedule'
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     permissions:
       contents: "read"
       id-token: "write"
@@ -35,11 +35,16 @@ jobs:
         run: pipx install poetry
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           cache: "poetry"
 
+      - name: Setup Node.js
+        uses: useblacksmith/setup-node@v5
+        with:
+          node-version: '22.x'
+
       - name: Comment on PR if 'integration-test' label is present
         if: github.event_name == 'pull_request' && github.event.label.name == 'integration-test'
         uses: KeisukeYamashita/create-comment@v1
@@ -49,7 +54,7 @@ jobs:
             Hi! I started running the integration tests on your PR. You will receive a comment with the results shortly.
 
       - name: Install Python dependencies using Poetry
-        run: poetry install --without evaluation,llama-index
+        run: poetry install --without evaluation
 
       - name: Configure config.toml for testing with Haiku
         env:
@@ -112,66 +117,33 @@ jobs:
           echo "EOF" >> $GITHUB_ENV
 
       # -------------------------------------------------------------
-      # Run DelegatorAgent tests for Haiku, limited to t01 and t02
+      # Run VisualBrowsingAgent tests for DeepSeek, limited to t05 and t06
       - name: Wait a little bit (again)
         run: sleep 5
 
-      - name: Configure config.toml for testing DelegatorAgent (Haiku)
-        env:
-          LLM_MODEL: "litellm_proxy/claude-3-5-haiku-20241022"
-          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
-          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-          MAX_ITERATIONS: 30
-        run: |
-          echo "[llm.eval]" > config.toml
-          echo "model = \"$LLM_MODEL\"" >> config.toml
-          echo "api_key = \"$LLM_API_KEY\"" >> config.toml
-          echo "base_url = \"$LLM_BASE_URL\"" >> config.toml
-          echo "temperature = 0.0" >> config.toml
-
-      - name: Run integration test evaluation for DelegatorAgent (Haiku)
-        env:
-          SANDBOX_FORCE_REBUILD_RUNTIME: True
-        run: |
-          poetry run ./evaluation/integration_tests/scripts/run_infer.sh llm.eval HEAD DelegatorAgent '' 30 $N_PROCESSES "t01_fix_simple_typo,t02_add_bash_hello" 'delegator_haiku_run'
-
-          # Find and export the delegator test results
-          REPORT_FILE_DELEGATOR_HAIKU=$(find evaluation/evaluation_outputs/outputs/integration_tests/DelegatorAgent/*haiku*_maxiter_30_N* -name "report.md" -type f | head -n 1)
-          echo "REPORT_FILE_DELEGATOR_HAIKU: $REPORT_FILE_DELEGATOR_HAIKU"
-          echo "INTEGRATION_TEST_REPORT_DELEGATOR_HAIKU<<EOF" >> $GITHUB_ENV
-          cat $REPORT_FILE_DELEGATOR_HAIKU >> $GITHUB_ENV
-          echo >> $GITHUB_ENV
-          echo "EOF" >> $GITHUB_ENV
-
-      # -------------------------------------------------------------
-      # Run DelegatorAgent tests for DeepSeek, limited to t01 and t02
-      - name: Wait a little bit (again)
-        run: sleep 5
-
-      - name: Configure config.toml for testing DelegatorAgent (DeepSeek)
+      - name: Configure config.toml for testing VisualBrowsingAgent (DeepSeek)
         env:
           LLM_MODEL: "litellm_proxy/deepseek-chat"
           LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
           LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
-          MAX_ITERATIONS: 30
+          MAX_ITERATIONS: 15
         run: |
           echo "[llm.eval]" > config.toml
           echo "model = \"$LLM_MODEL\"" >> config.toml
           echo "api_key = \"$LLM_API_KEY\"" >> config.toml
           echo "base_url = \"$LLM_BASE_URL\"" >> config.toml
           echo "temperature = 0.0" >> config.toml
-
-      - name: Run integration test evaluation for DelegatorAgent (DeepSeek)
+      - name: Run integration test evaluation for VisualBrowsingAgent (DeepSeek)
         env:
           SANDBOX_FORCE_REBUILD_RUNTIME: True
         run: |
-          poetry run ./evaluation/integration_tests/scripts/run_infer.sh llm.eval HEAD DelegatorAgent '' 30 $N_PROCESSES "t01_fix_simple_typo,t02_add_bash_hello" 'delegator_deepseek_run'
+          poetry run ./evaluation/integration_tests/scripts/run_infer.sh llm.eval HEAD VisualBrowsingAgent '' 15 $N_PROCESSES "t05_simple_browsing,t06_github_pr_browsing.py" 'visualbrowsing_deepseek_run'
 
-          # Find and export the delegator test results
-          REPORT_FILE_DELEGATOR_DEEPSEEK=$(find evaluation/evaluation_outputs/outputs/integration_tests/DelegatorAgent/deepseek*_maxiter_30_N* -name "report.md" -type f | head -n 1)
-          echo "REPORT_FILE_DELEGATOR_DEEPSEEK: $REPORT_FILE_DELEGATOR_DEEPSEEK"
-          echo "INTEGRATION_TEST_REPORT_DELEGATOR_DEEPSEEK<<EOF" >> $GITHUB_ENV
-          cat $REPORT_FILE_DELEGATOR_DEEPSEEK >> $GITHUB_ENV
+          # Find and export the visual browsing agent test results
+          REPORT_FILE_VISUALBROWSING_DEEPSEEK=$(find evaluation/evaluation_outputs/outputs/integration_tests/VisualBrowsingAgent/deepseek*_maxiter_15_N* -name "report.md" -type f | head -n 1)
+          echo "REPORT_FILE_VISUALBROWSING_DEEPSEEK: $REPORT_FILE_VISUALBROWSING_DEEPSEEK"
+          echo "INTEGRATION_TEST_REPORT_VISUALBROWSING_DEEPSEEK<<EOF" >> $GITHUB_ENV
+          cat $REPORT_FILE_VISUALBROWSING_DEEPSEEK >> $GITHUB_ENV
           echo >> $GITHUB_ENV
           echo "EOF" >> $GITHUB_ENV
 
@@ -179,7 +151,7 @@ jobs:
         run: |
           TIMESTAMP=$(date +'%y-%m-%d-%H-%M')
           cd evaluation/evaluation_outputs/outputs  # Change to the outputs directory
-          tar -czvf ../../../integration_tests_${TIMESTAMP}.tar.gz integration_tests/CodeActAgent/* integration_tests/DelegatorAgent/*  # Only include the actual result directories
+          tar -czvf ../../../integration_tests_${TIMESTAMP}.tar.gz integration_tests/CodeActAgent/* integration_tests/VisualBrowsingAgent/* # Only include the actual result directories
 
       - name: Upload evaluation results as artifact
         uses: actions/upload-artifact@v4
@@ -221,10 +193,7 @@ jobs:
               DeepSeek LLM Test Results:
               ${{ env.INTEGRATION_TEST_REPORT_DEEPSEEK }}
               ---
-                **Integration Tests Report Delegator (Haiku)**
-              ${{ env.INTEGRATION_TEST_REPORT_DELEGATOR_HAIKU }}
-              ---
-              **Integration Tests Report Delegator (DeepSeek)**
-              ${{ env.INTEGRATION_TEST_REPORT_DELEGATOR_DEEPSEEK }}
+              **Integration Tests Report VisualBrowsing (DeepSeek)**
+              ${{ env.INTEGRATION_TEST_REPORT_VISUALBROWSING_DEEPSEEK }}
               ---
               Download testing outputs (includes both Haiku and DeepSeek results): [Download](${{ steps.upload_results_artifact.outputs.artifact-url }})

.github/workflows/lint-fix.yml

@@ -9,7 +9,7 @@ jobs:
   lint-fix-frontend:
     if: github.event.label.name == 'lint-fix'
     name: Fix frontend linting issues
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     permissions:
       contents: write
       pull-requests: write
@@ -22,7 +22,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Install Node.js 20
-        uses: actions/setup-node@v4
+        uses: useblacksmith/setup-node@v5
         with:
           node-version: 20
       - name: Install frontend dependencies
@@ -52,7 +52,7 @@ jobs:
   lint-fix-python:
     if: github.event.label.name == 'lint-fix'
     name: Fix Python linting issues
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     permissions:
       contents: write
       pull-requests: write
@@ -65,7 +65,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Set up python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: 3.12
           cache: 'pip'

.github/workflows/lint.yml

@@ -19,11 +19,11 @@ jobs:
   # Run lint on the frontend code
   lint-frontend:
     name: Lint frontend
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
       - name: Install Node.js 20
-        uses: actions/setup-node@v4
+        uses: useblacksmith/setup-node@v5
         with:
           node-version: 20
       - name: Install dependencies
@@ -39,13 +39,13 @@ jobs:
   # Run lint on the python code
   lint-python:
     name: Lint python
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Set up python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: 3.12
           cache: 'pip'
@@ -57,11 +57,11 @@ jobs:
   # Check version consistency across documentation
   check-version-consistency:
     name: Check version consistency
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
       - name: Set up python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: 3.12
       - name: Run version consistency check

.github/workflows/openhands-resolver.yml

@@ -20,6 +20,10 @@ on:
         required: false
         type: string
         default: "anthropic/claude-3-5-sonnet-20241022"
+      LLM_API_VERSION:
+        required: false
+        type: string
+        default: ""
       base_container_image:
         required: false
         type: string
@@ -84,8 +88,10 @@ jobs:
         run: |
           python -m pip index versions openhands-ai > openhands_versions.txt
           OPENHANDS_VERSION=$(head -n 1 openhands_versions.txt | awk '{print $2}' | tr -d '()')
-          echo "openhands-ai==${OPENHANDS_VERSION}" >> requirements.txt
-          cat requirements.txt
+
+          # Create a new requirements.txt locally within the workflow, ensuring no reference to the repo's file
+          echo "openhands-ai==${OPENHANDS_VERSION}" > /tmp/requirements.txt
+          cat /tmp/requirements.txt
 
       - name: Cache pip dependencies
         if: |
@@ -103,15 +109,16 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ${{ env.pythonLocation }}/lib/python3.12/site-packages/*
-          key: ${{ runner.os }}-pip-openhands-resolver-${{ hashFiles('requirements.txt') }}
+          key: ${{ runner.os }}-pip-openhands-resolver-${{ hashFiles('/tmp/requirements.txt') }}
           restore-keys: |
-            ${{ runner.os }}-pip-openhands-resolver-${{ hashFiles('requirements.txt') }}
+            ${{ runner.os }}-pip-openhands-resolver-${{ hashFiles('/tmp/requirements.txt') }}
 
       - name: Check required environment variables
         env:
           LLM_MODEL: ${{ secrets.LLM_MODEL || inputs.LLM_MODEL }}
           LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
           LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
+          LLM_API_VERSION: ${{ inputs.LLM_API_VERSION }}
           PAT_TOKEN: ${{ secrets.PAT_TOKEN }}
           PAT_USERNAME: ${{ secrets.PAT_USERNAME }}
           GITHUB_TOKEN: ${{ github.token }}
@@ -168,7 +175,7 @@ jobs:
           echo "SANDBOX_ENV_BASE_CONTAINER_IMAGE=${{ inputs.base_container_image }}" >> $GITHUB_ENV
 
           # Set branch variables
-          echo "TARGET_BRANCH=${{ inputs.target_branch }}" >> $GITHUB_ENV
+          echo "TARGET_BRANCH=${{ inputs.target_branch || 'main' }}" >> $GITHUB_ENV
 
       - name: Comment on issue with start message
         uses: actions/github-script@v7
@@ -184,6 +191,7 @@ jobs:
             });
 
       - name: Install OpenHands
+        id: install_openhands
         uses: actions/github-script@v7
         env:
           COMMENT_BODY: ${{ github.event.comment.body || '' }}
@@ -196,7 +204,6 @@ jobs:
             const reviewBody = process.env.REVIEW_BODY.trim();
             const labelName = process.env.LABEL_NAME.trim();
             const eventName = process.env.EVENT_NAME.trim();
-
             // Check conditions
             const isExperimentalLabel = labelName === "fix-me-experimental";
             const isIssueCommentExperimental =
@@ -205,6 +212,9 @@ jobs:
             const isReviewCommentExperimental =
               eventName === "pull_request_review" && reviewBody.includes("@openhands-agent-exp");
 
+            // Set output variable
+            core.setOutput('isExperimental', isExperimentalLabel || isIssueCommentExperimental || isReviewCommentExperimental);
+
             // Perform package installation
             if (isExperimentalLabel || isIssueCommentExperimental || isReviewCommentExperimental) {
               console.log("Installing experimental OpenHands...");
@@ -213,16 +223,18 @@ jobs:
             } else {
               console.log("Installing from requirements.txt...");
               await exec.exec("python -m pip install --upgrade pip");
-              await exec.exec("pip install -r requirements.txt");
+              await exec.exec("pip install -r /tmp/requirements.txt");
             }
 
       - name: Attempt to resolve issue
         env:
           GITHUB_TOKEN: ${{ secrets.PAT_TOKEN || github.token }}
           GITHUB_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
+          GIT_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
           LLM_MODEL: ${{ secrets.LLM_MODEL || inputs.LLM_MODEL }}
           LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
           LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
+          LLM_API_VERSION: ${{ inputs.LLM_API_VERSION }}
           PYTHONPATH: ""
         run: |
           cd /tmp && python -m openhands.resolver.resolve_issue \
@@ -230,7 +242,8 @@ jobs:
             --issue-number ${{ env.ISSUE_NUMBER }} \
             --issue-type ${{ env.ISSUE_TYPE }} \
             --max-iterations ${{ env.MAX_ITERATIONS }} \
-            --comment-id ${{ env.COMMENT_ID }}
+            --comment-id ${{ env.COMMENT_ID }} \
+            --is-experimental ${{ steps.install_openhands.outputs.isExperimental }}
 
       - name: Check resolution result
         id: check_result
@@ -254,14 +267,17 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.PAT_TOKEN || github.token }}
           GITHUB_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
+          GIT_USERNAME: ${{ secrets.PAT_USERNAME || 'openhands-agent' }}
           LLM_MODEL: ${{ secrets.LLM_MODEL || inputs.LLM_MODEL }}
           LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
           LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
+          LLM_API_VERSION: ${{ inputs.LLM_API_VERSION }}
           PYTHONPATH: ""
         run: |
           if [ "${{ steps.check_result.outputs.RESOLUTION_SUCCESS }}" == "true" ]; then
             cd /tmp && python -m openhands.resolver.send_pull_request \
               --issue-number ${{ env.ISSUE_NUMBER }} \
+              --target-branch ${{ env.TARGET_BRANCH }} \
               --pr-type draft \
               --reviewer ${{ github.actor }} | tee pr_result.txt && \
               grep "draft created" pr_result.txt | sed 's/.*\///g' > pr_number.txt
@@ -279,11 +295,12 @@ jobs:
         if: always()
         env:
           AGENT_RESPONDED: ${{ env.AGENT_RESPONDED || 'false' }}
+          ISSUE_NUMBER: ${{ env.ISSUE_NUMBER }}
         with:
           github-token: ${{ secrets.PAT_TOKEN || github.token }}
           script: |
             const fs = require('fs');
-            const issueNumber = ${{ env.ISSUE_NUMBER }};
+            const issueNumber = process.env.ISSUE_NUMBER;
             let logContent = '';
 
             try {
@@ -314,13 +331,15 @@ jobs:
         if: always() # Comment on issue even if the previous steps fail
         env:
           AGENT_RESPONDED: ${{ env.AGENT_RESPONDED || 'false' }}
+          ISSUE_NUMBER: ${{ env.ISSUE_NUMBER }}
+          RESOLUTION_SUCCESS: ${{ steps.check_result.outputs.RESOLUTION_SUCCESS }}
         with:
           github-token: ${{ secrets.PAT_TOKEN || github.token }}
           script: |
             const fs = require('fs');
             const path = require('path');
-            const issueNumber = ${{ env.ISSUE_NUMBER }};
-            const success = ${{ steps.check_result.outputs.RESOLUTION_SUCCESS }};
+            const issueNumber = process.env.ISSUE_NUMBER;
+            const success = process.env.RESOLUTION_SUCCESS === 'true';
 
             let prNumber = '';
             let branchName = '';
@@ -385,10 +404,12 @@ jobs:
       - name: Fallback Error Comment
         uses: actions/github-script@v7
         if: ${{ env.AGENT_RESPONDED == 'false' }} # Only run if no conditions were met in previous steps
+        env:
+          ISSUE_NUMBER: ${{ env.ISSUE_NUMBER }}
         with:
           github-token: ${{ secrets.PAT_TOKEN || github.token }}
           script: |
-            const issueNumber = ${{ env.ISSUE_NUMBER }};
+            const issueNumber = process.env.ISSUE_NUMBER;
 
             github.rest.issues.createComment({
               issue_number: issueNumber,

.github/workflows/py-unit-tests-mac.yml

@@ -1,98 +0,0 @@
-# Workflow that runs python unit tests on mac
-name: Run Python Unit Tests Mac
-
-# This job is flaky so only run it nightly
-on:
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  # Run python unit tests on macOS
-  test-on-macos:
-    name: Python Unit Tests on macOS
-    runs-on: macos-14
-    env:
-      INSTALL_DOCKER: '1' # Set to '0' to skip Docker installation
-    strategy:
-      matrix:
-        python-version: ['3.12']
-    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 Poetry dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cache/pypoetry
-            ~/.virtualenvs
-          key: ${{ runner.os }}-poetry-${{ hashFiles('**/poetry.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-poetry-
-      - name: Install tmux
-        run: brew install tmux
-      - name: Install poetry via pipx
-        run: pipx install poetry
-      - name: Install Python dependencies using Poetry
-        run: poetry install --without evaluation,llama-index
-      - name: Install & Start Docker
-        if: env.INSTALL_DOCKER == '1'
-        run: |
-          INSTANCE_NAME="colima-${GITHUB_RUN_ID}"
-
-          # Uninstall colima to upgrade to the latest version
-          if brew list colima &>/dev/null; then
-            brew uninstall colima
-            # unlinking colima dependency: go
-            brew uninstall go@1.21
-          fi
-          rm -rf ~/.colima ~/.lima
-          brew install --HEAD colima
-          brew install docker
-
-          start_colima() {
-            # Find a free port in the range 10000-20000
-            RANDOM_PORT=$((RANDOM % 10001 + 10000))
-
-            # Original line:
-            if ! colima start --network-address --arch x86_64 --cpu=1 --memory=1 --verbose --ssh-port $RANDOM_PORT; then
-              echo "Failed to start Colima."
-              return 1
-            fi
-            return 0
-          }
-
-          # Attempt to start Colima for 5 total attempts:
-          ATTEMPT_LIMIT=5
-          for ((i=1; i<=ATTEMPT_LIMIT; i++)); do
-
-            if start_colima; then
-              echo "Colima started successfully."
-              break
-            else
-              colima stop -f
-              sleep 10
-              colima delete -f
-              if [ $i -eq $ATTEMPT_LIMIT ]; then
-                exit 1
-              fi
-              sleep 10
-            fi
-          done
-
-          # For testcontainers to find the Colima socket
-          # https://github.com/abiosoft/colima/blob/main/docs/FAQ.md#cannot-connect-to-the-docker-daemon-at-unixvarrundockersock-is-the-docker-daemon-running
-          sudo ln -sf $HOME/.colima/default/docker.sock /var/run/docker.sock
-      - name: Build Environment
-        run: make build
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Run Tests
-        run: poetry run pytest --forked --cov=openhands --cov-report=xml ./tests/unit --ignore=tests/unit/test_memory.py
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/py-unit-tests.yml

@@ -19,7 +19,7 @@ jobs:
   # Run python unit tests on Linux
   test-on-linux:
     name: Python Unit Tests on Linux
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     env:
       INSTALL_DOCKER: '0' # Set to '0' to skip Docker installation
     strategy:
@@ -32,19 +32,23 @@ jobs:
         uses: docker/setup-buildx-action@v3
       - name: Install tmux
         run: sudo apt-get update && sudo apt-get install -y tmux
+      - name: Setup Node.js
+        uses: useblacksmith/setup-node@v5
+        with:
+          node-version: '22.x'
       - name: Install poetry via pipx
         run: pipx install poetry
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: useblacksmith/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           cache: 'poetry'
       - name: Install Python dependencies using Poetry
-        run: poetry install --without evaluation,llama-index
+        run: poetry install --without evaluation
       - name: Build Environment
         run: make build
       - name: Run Tests
-        run: poetry run pytest --forked -n auto --cov=openhands --cov-report=xml -svv ./tests/unit --ignore=tests/unit/test_memory.py
+        run: poetry run pytest --forked -n auto --cov=openhands --cov-report=xml -svv ./tests/unit
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5
         env:

.github/workflows/pypi-release.yml

@@ -12,10 +12,10 @@ on:
 
 jobs:
   release:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: useblacksmith/setup-python@v6
         with:
           python-version: 3.12
       - name: Install Poetry

.github/workflows/run-eval.yml

@@ -10,7 +10,7 @@ jobs:
   trigger-job:
     name: Trigger remote eval job
     if: ${{ github.event.label.name == 'run-eval-xs' || github.event.label.name == 'run-eval-s' || github.event.label.name == 'run-eval-m' }}
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
 
     steps:
       - name: Checkout PR branch

.github/workflows/stale.yml

@@ -8,7 +8,7 @@ on:
 
 jobs:
   stale:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2204
     steps:
       - uses: actions/stale@v9
         with:
@@ -19,3 +19,4 @@ jobs:
           close-issue-message: 'This issue was closed because it has been stalled for over 30 days with no activity.'
           close-pr-message: 'This PR was closed because it has been stalled for over 30 days with no activity.'
           days-before-close: 7
+          operations-per-run: 150

.openhands/microagents/glossary.md

@@ -0,0 +1,172 @@
+# OpenHands Glossary
+
+### Agent
+The core AI entity in OpenHands that can perform software development tasks by interacting with tools, browsing the web, and modifying code.
+
+#### Agent Controller
+A component that manages the agent's lifecycle, handles its state, and coordinates interactions between the agent and various tools.
+
+#### Agent Delegation
+The ability of an agent to hand off specific tasks to other specialized agents for better task completion.
+
+#### Agent Hub
+A central registry of different agent types and their capabilities, allowing for easy agent selection and instantiation.
+
+#### Agent Skill
+A specific capability or function that an agent can perform, such as file manipulation, web browsing, or code editing.
+
+#### Agent State
+The current context and status of an agent, including its memory, active tools, and ongoing tasks.
+
+#### CodeAct Agent
+[A generalist agent in OpenHands](https://arxiv.org/abs/2407.16741) designed to perform tasks by editing and executing code.
+
+### Browser
+A system for web-based interactions and tasks.
+
+#### Browser Gym
+A testing and evaluation environment for browser-based agent interactions and tasks.
+
+#### Web Browser Tool
+A tool that enables agents to interact with web pages and perform web-based tasks.
+
+### Commands
+Terminal and execution related functionality.
+
+#### Bash Session
+A persistent terminal session that maintains state and history for bash command execution.
+This uses tmux under the hood.
+
+### Configuration
+System-wide settings and options.
+
+#### Agent Configuration
+Settings that define an agent's behavior, capabilities, and limitations, including available tools and runtime settings.
+
+#### Configuration Options
+Settings that control various aspects of OpenHands behavior, including runtime, security, and agent settings.
+
+#### LLM Config
+Configuration settings for language models used by agents, including model selection and parameters.
+
+#### LLM Draft Config
+Settings for draft mode operations with language models, typically used for faster, lower-quality responses.
+
+#### Runtime Configuration
+Settings that define how the runtime environment should be set up and operated.
+
+#### Security Options
+Configuration settings that control security features and restrictions.
+
+### Conversation
+A sequence of interactions between a user and an agent, including messages, actions, and their results.
+
+#### Conversation Info
+Metadata about a conversation, including its status, participants, and timeline.
+
+#### Conversation Manager
+A component that handles the creation, storage, and retrieval of conversations.
+
+#### Conversation Metadata
+Additional information about conversations, such as tags, timestamps, and related resources.
+
+#### Conversation Status
+The current state of a conversation, including whether it's active, completed, or failed.
+
+#### Conversation Store
+A storage system for maintaining conversation history and related data.
+
+### Events
+
+#### Event
+Every Conversation comprises a series of Events. Each Event is either an Action or an Observation.
+
+#### Event Stream
+A continuous flow of events that represents the ongoing activities and interactions in the system.
+
+#### Action
+A specific operation or command that an agent executes through available tools, such as running a command or editing a file.
+
+#### Observation
+The response or result returned by a tool after an agent's action, providing feedback about the action's outcome.
+
+### Interface
+Different ways to interact with OpenHands.
+
+#### CLI Mode
+A command-line interface mode for interacting with OpenHands agents without a graphical interface.
+
+#### GUI Mode
+A graphical user interface mode for interacting with OpenHands agents through a web interface.
+
+#### Headless Mode
+A mode of operation where OpenHands runs without a user interface, suitable for automation and scripting.
+
+### Agent Memory
+The system that decides which parts of the Event Stream (i.e. the conversation history) should be passed into each LLM prompt.
+
+#### Memory Store
+A storage system for maintaining agent memory and context across sessions.
+
+#### Condenser
+A component that processes and summarizes conversation history to maintain context while staying within token limits.
+
+#### Truncation
+A very simple Condenser strategy. Reduces conversation history or content to stay within token limits.
+
+### Microagent
+A specialized prompt that enhances OpenHands with domain-specific knowledge, repository-specific context, and task-specific workflows.
+
+#### Microagent Registry
+A central repository of available microagents and their configurations.
+
+#### Public Microagent
+A general-purpose microagent available to all OpenHands users, triggered by specific keywords.
+
+#### Repository Microagent
+A type of microagent that provides repository-specific context and guidelines, stored in the `.openhands/microagents/` directory.
+
+### Prompt
+Components for managing and processing prompts.
+
+#### Prompt Caching
+A system for caching and reusing common prompts to improve performance.
+
+#### Prompt Manager
+A component that handles the loading, processing, and management of prompts used by agents, including microagents.
+
+#### Response Parsing
+The process of interpreting and structuring responses from language models and tools.
+
+### Runtime
+The execution environment where agents perform their tasks, which can be local, remote, or containerized.
+
+#### Action Execution Server
+A REST API that receives agent actions (e.g. bash commands, python code, browsing actions), executes them in the runtime environment, and returns the results.
+
+#### Action Execution Client
+A component that handles the execution of actions in the runtime environment, managing the communication between the agent and the runtime.
+
+#### Docker Runtime
+A containerized runtime environment that provides isolation and reproducibility for agent operations.
+
+#### E2B Runtime
+A specialized runtime environment built on E2B for secure and isolated code execution.
+
+#### Local Runtime
+A runtime environment that executes on the local machine, suitable for development and testing.
+
+#### Modal Runtime
+A runtime environment built on Modal for scalable and distributed agent operations.
+
+#### Remote Runtime
+A sandboxed environment that executes code and commands remotely, providing isolation and security for agent operations.
+
+#### Runtime Builder
+A component that builds a Docker image for the Action Execution Server based on a user-specified base image.
+
+### Security
+Security-related components and features.
+
+#### Security Analyzer
+A component that checks agent actions for potential security risks.

.openhands/microagents/repo.md

@@ -33,6 +33,7 @@ Frontend:
 - Testing:
   - Run tests: `npm run test`
   - To run specific tests: `npm run test -- -t "TestName"`
+  - Our test framework is vitest
 - Building:
   - Build for production: `npm run build`
 - Environment Variables:
@@ -40,3 +41,8 @@ Frontend:
   - Available variables: VITE_BACKEND_HOST, VITE_USE_TLS, VITE_INSECURE_SKIP_VERIFY, VITE_FRONTEND_PORT
 - Internationalization:
   - Generate i18n declaration file: `npm run make-i18n`
+
+
+## Template for Github Pull Request
+
+If you are starting a pull request (PR), please follow the template in `.github/pull_request_template.md`.

.openhands/setup.sh

@@ -0,0 +1,5 @@
+#! /bin/bash
+
+echo "Setting up the environment..."
+
+python -m pip install pre-commit

CITATION.cff

@@ -0,0 +1,55 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it using the following metadata."
+title: "OpenHands: An Open Platform for AI Software Developers as Generalist Agents"
+authors:
+  - family-names: Wang
+    given-names: Xingyao
+  - family-names: Li
+    given-names: Boxuan
+  - family-names: Song
+    given-names: Yufan
+  - family-names: Xu
+    given-names: Frank F.
+  - family-names: Tang
+    given-names: Xiangru
+  - family-names: Zhuge
+    given-names: Mingchen
+  - family-names: Pan
+    given-names: Jiayi
+  - family-names: Song
+    given-names: Yueqi
+  - family-names: Li
+    given-names: Bowen
+  - family-names: Singh
+    given-names: Jaskirat
+  - family-names: Tran
+    given-names: Hoang H.
+  - family-names: Li
+    given-names: Fuqiang
+  - family-names: Ma
+    given-names: Ren
+  - family-names: Zheng
+    given-names: Mingzhang
+  - family-names: Qian
+    given-names: Bill
+  - family-names: Shao
+    given-names: Yanjun
+  - family-names: Muennighoff
+    given-names: Niklas
+  - family-names: Zhang
+    given-names: Yizhe
+  - family-names: Hui
+    given-names: Binyuan
+  - family-names: Lin
+    given-names: Junyang
+  - family-names: Brennan
+    given-names: Robert
+  - family-names: Peng
+    given-names: Hao
+  - family-names: Ji
+    given-names: Heng
+  - family-names: Neubig
+    given-names: Graham
+year: 2024
+doi: "10.48550/arXiv.2407.16741"
+url: "https://arxiv.org/abs/2407.16741"

CODE_OF_CONDUCT.md

@@ -113,6 +113,20 @@ individual, or aggression toward or disparagement of classes of individuals.
 **Consequence**: A permanent ban from any sort of public interaction within the
 community.
 
+### Slack and Discord Etiquettes
+
+These Slack and Discord etiquette guidelines are designed to foster an inclusive, respectful, and productive environment for all community members. By following these best practices, we ensure effective communication and collaboration while minimizing disruptions. Let’s work together to build a supportive and welcoming community!
+
+- Communicate respectfully and professionally, avoiding sarcasm or harsh language, and remember that tone can be difficult to interpret in text.
+- Use threads for specific discussions to keep channels organized and easier to follow.
+- Tag others only when their input is critical or urgent, and use @here, @channel or @everyone sparingly to minimize disruptions.
+- Be patient, as open-source contributors and maintainers often have other commitments and may need time to respond.
+- Post questions or discussions in the most relevant channel (e.g., for [slack - #general](https://app.slack.com/client/T06P212QSEA/C06P5NCGSFP) for general topics, [slack - #questions](https://openhands-ai.slack.com/archives/C06U8UTKSAD) for queries/questions, [discord - #general](https://discord.com/channels/1222935860639563850/1222935861386018885)).
+- When asking for help or raising issues, include necessary details like links, screenshots, or clear explanations to provide context.
+- Keep discussions in public channels whenever possible to allow others to benefit from the conversation, unless the matter is sensitive or private.
+- Always adhere to [our standards](https://github.com/All-Hands-AI/OpenHands/blob/main/CODE_OF_CONDUCT.md#our-standards) to ensure a welcoming and collaborative environment.
+- If you choose to mute a channel, consider setting up alerts for topics that still interest you to stay engaged. For Slack, Go to Settings → Notifications → My Keywords to add specific keywords that will notify you when mentioned. For example, if you're here for discussions about LLMs, mute the channel if it’s too busy, but set notifications to alert you only when “LLMs” appears in messages. Also for Discord, go to the channel notifications and choose the option that best describes your need.
+
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage],

Development.md

@@ -1,22 +1,26 @@
 # Development Guide
+
 This guide is for people working on OpenHands and editing the source code.
 If you wish to contribute your changes, check out the [CONTRIBUTING.md](https://github.com/All-Hands-AI/OpenHands/blob/main/CONTRIBUTING.md) on how to clone and setup the project initially before moving on.
 Otherwise, you can clone the OpenHands project directly.
 
 ## Start the Server for Development
+
 ### 1. Requirements
-* Linux, Mac OS, or [WSL on Windows](https://learn.microsoft.com/en-us/windows/wsl/install)  [Ubuntu <= 22.04]
-* [Docker](https://docs.docker.com/engine/install/) (For those on MacOS, make sure to allow the default Docker socket to be used from advanced settings!)
-* [Python](https://www.python.org/downloads/) = 3.12
-* [NodeJS](https://nodejs.org/en/download/package-manager) >= 20.x
-* [Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer) >= 1.8
-* OS-specific dependencies:
+
+- Linux, Mac OS, or [WSL on Windows](https://learn.microsoft.com/en-us/windows/wsl/install) [Ubuntu >= 22.04]
+- [Docker](https://docs.docker.com/engine/install/) (For those on MacOS, make sure to allow the default Docker socket to be used from advanced settings!)
+- [Python](https://www.python.org/downloads/) = 3.12
+- [NodeJS](https://nodejs.org/en/download/package-manager) >= 20.x
+- [Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer) >= 1.8
+- OS-specific dependencies:
   - Ubuntu: build-essential => `sudo apt-get install build-essential`
   - WSL: netcat => `sudo apt-get install netcat`
 
 Make sure you have all these dependencies installed before moving on to `make build`.
 
 #### Develop without sudo access
+
 If you want to develop without system admin/sudo access to upgrade/install `Python` and/or `NodeJs`, you can use `conda` or `mamba` to manage the packages for you:
 
 ```bash
@@ -31,6 +35,7 @@ mamba install conda-forge::poetry
 ```
 
 ### 2. Build and Setup The Environment
+
 Begin by building the project which includes setting up the environment and installing dependencies. This step ensures that OpenHands is ready to run on your system:
 
 ```bash
@@ -38,54 +43,65 @@ make build
 ```
 
 ### 3. Configuring the Language Model
+
 OpenHands supports a diverse array of Language Models (LMs) through the powerful [litellm](https://docs.litellm.ai) library.
 By default, we've chosen Claude Sonnet 3.5 as our go-to model, but the world is your oyster! You can unleash the
 potential of any other LM that piques your interest.
 
 To configure the LM of your choice, run:
 
-   ```bash
-   make setup-config
-   ```
+```bash
+make setup-config
+```
 
-   This command will prompt you to enter the LLM API key, model name, and other variables ensuring that OpenHands is tailored to your specific needs. Note that the model name will apply only when you run headless. If you use the UI, please set the model in the UI.
+This command will prompt you to enter the LLM API key, model name, and other variables ensuring that OpenHands is tailored to your specific needs. Note that the model name will apply only when you run headless. If you use the UI, please set the model in the UI.
 
-   Note: If you have previously run OpenHands using the docker command, you may have already set some environmental variables in your terminal. The final configurations are set from highest to lowest priority:
-   Environment variables > config.toml variables > default variables
+Note: If you have previously run OpenHands using the docker command, you may have already set some environmental variables in your terminal. The final configurations are set from highest to lowest priority:
+Environment variables > config.toml variables > default variables
 
 **Note on Alternative Models:**
 See [our documentation](https://docs.all-hands.dev/modules/usage/llms) for recommended models.
 
 ### 4. Running the application
+
 #### Option A: Run the Full Application
+
 Once the setup is complete, this command starts both the backend and frontend servers, allowing you to interact with OpenHands:
+
 ```bash
 make run
 ```
 
 #### Option B: Individual Server Startup
+
 - **Start the Backend Server:** If you prefer, you can start the backend server independently to focus on backend-related tasks or configurations.
-    ```bash
-    make start-backend
-    ```
+
+  ```bash
+  make start-backend
+  ```
 
 - **Start the Frontend Server:** Similarly, you can start the frontend server on its own to work on frontend-related components or interface enhancements.
-    ```bash
-    make start-frontend
-    ```
+  ```bash
+  make start-frontend
+  ```
 
 ### 6. LLM Debugging
+
 If you encounter any issues with the Language Model (LM) or you're simply curious, export DEBUG=1 in the environment and restart the backend.
 OpenHands will log the prompts and responses in the logs/llm/CURRENT_DATE directory, allowing you to identify the causes.
 
 ### 7. Help
+
 Need help or info on available targets and commands? Use the help command for all the guidance you need with OpenHands.
+
 ```bash
 make help
- ```
+```
 
 ### 8. Testing
+
 To run tests, refer to the following:
+
 #### Unit tests
 
 ```bash
@@ -93,14 +109,16 @@ poetry run pytest ./tests/unit/test_*.py
 ```
 
 ### 9. Add or update dependency
+
 1. Add your dependency in `pyproject.toml` or use `poetry add xxx`.
 2. Update the poetry.lock file via `poetry lock --no-update`.
 
 ### 9. Use existing Docker image
+
 To reduce build time (e.g., if no changes were made to the client-runtime component), you can use an existing Docker container image by
 setting the SANDBOX_RUNTIME_CONTAINER_IMAGE environment variable to the desired Docker image.
 
-Example: `export SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.20-nikolaik`
+Example: `export SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.29-nikolaik`
 
 ## Develop inside Docker container
 
@@ -126,3 +144,20 @@ cd ./containers/dev
 ```
 
 You do need [Docker](https://docs.docker.com/engine/install/) installed on your host though.
+
+## Key Documentation Resources
+
+Here's a guide to the important documentation files in the repository:
+
+- [/README.md](./README.md): Main project overview, features, and basic setup instructions
+- [/Development.md](./Development.md) (this file): Comprehensive guide for developers working on OpenHands
+- [/CONTRIBUTING.md](./CONTRIBUTING.md): Guidelines for contributing to the project, including code style and PR process
+- [/docs/DOC_STYLE_GUIDE.md](./docs/DOC_STYLE_GUIDE.md): Standards for writing and maintaining project documentation
+- [/openhands/README.md](./openhands/README.md): Details about the backend Python implementation
+- [/frontend/README.md](./frontend/README.md): Frontend React application setup and development guide
+- [/containers/README.md](./containers/README.md): Information about Docker containers and deployment
+- [/tests/unit/README.md](./tests/unit/README.md): Guide to writing and running unit tests
+- [/evaluation/README.md](./evaluation/README.md): Documentation for the evaluation framework and benchmarks
+- [/microagents/README.md](./microagents/README.md): Information about the microagents architecture and implementation
+- [/openhands/server/README.md](./openhands/server/README.md): Server implementation details and API documentation
+- [/openhands/runtime/README.md](./openhands/runtime/README.md): Documentation for the runtime environment and execution model

ISSUE_TRIAGE.md

@@ -2,12 +2,13 @@
 These are the procedures and guidelines on how issues are triaged in this repo by the maintainers.
 
 ## General
-* Most issues must be tagged with **enhancement** or **bug**.
-* Issues may be tagged with what it relates to (**backend**, **frontend**, **agent quality**, etc.).
+* All issues must be tagged with **enhancement**, **bug** or **troubleshooting/help**.
+* Issues may be tagged with what it relates to (**agent quality**, **frontend**, **resolver**, etc.).
 
 ## Severity
 * **Low**: Minor issues or affecting single user.
 * **Medium**: Affecting multiple users.
+* **High**: High visibility issues or affecting many users.
 * **Critical**: Affecting all users or potential security issues.
 
 ## Effort
@@ -18,8 +19,14 @@ These are the procedures and guidelines on how issues are triaged in this repo b
 
 ## Not Enough Information
 * User is asked to provide more information (logs, how to reproduce, etc.) when the issue is not clear.
-* If an issue is unclear and the author does not provide more information or respond to a request, the issue may be closed as **not planned** (Usually after a week).
+* If an issue is unclear and the author does not provide more information or respond to a request,
+the issue may be closed as **not planned** (Usually after a week).
 
 ## Multiple Requests/Fixes in One Issue
 * These issues will be narrowed down to one request/fix so the issue is more easily tracked and fixed.
 * Issues may be broken down into multiple issues if required.
+
+## Stale and Auto Closures
+* In order to keep a maintainable backlog, issues that have no activity within 30 days are automatically marked as **Stale**.
+* If issues marked as **Stale** continue to have no activity for 7 more days, they will automatically be closed as not planned.
+* Issues may be reopened by maintainers if deemed important.

Makefile

@@ -1,4 +1,4 @@
-SHELL=/bin/bash
+SHELL=/usr/bin/env bash
 # Makefile for OpenHands project
 
 # Variables
@@ -81,10 +81,10 @@ check-nodejs:
 	@if command -v node > /dev/null; then \
 		NODE_VERSION=$(shell node --version | sed -E 's/v//g'); \
 		IFS='.' read -r -a NODE_VERSION_ARRAY <<< "$$NODE_VERSION"; \
-		if [ "$${NODE_VERSION_ARRAY[0]}" -ge 20 ]; then \
+		if [ "$${NODE_VERSION_ARRAY[0]}" -ge 22 ]; then \
 			echo "$(BLUE)Node.js $$NODE_VERSION is already installed.$(RESET)"; \
 		else \
-			echo "$(RED)Node.js 20.x or later is required. Please install Node.js 20.x or later to continue.$(RESET)"; \
+			echo "$(RED)Node.js 22.x or later is required. Please install Node.js 22.x or later to continue.$(RESET)"; \
 			exit 1; \
 		fi; \
 	else \
@@ -133,7 +133,7 @@ install-python-dependencies:
 		export HNSWLIB_NO_NATIVE=1; \
 		poetry run pip install chroma-hnswlib; \
 	fi
-	@poetry install --without llama-index
+	@poetry install
 	@if [ -f "/etc/manjaro-release" ]; then \
 		echo "$(BLUE)Detected Manjaro Linux. Installing Playwright dependencies...$(RESET)"; \
 		poetry run pip install playwright; \
@@ -265,35 +265,6 @@ setup-config-prompts:
 	@read -p "Enter your LLM base URL [mostly used for local LLMs, leave blank if not needed - example: http://localhost:5001/v1/]: " llm_base_url; \
 	 if [[ ! -z "$$llm_base_url" ]]; then echo "base_url=\"$$llm_base_url\"" >> $(CONFIG_FILE).tmp; fi
 
-	@echo "Enter your LLM Embedding Model"; \
-		echo "Choices are:"; \
-		echo "  - openai"; \
-		echo "  - azureopenai"; \
-		echo "  - Embeddings available only with OllamaEmbedding:"; \
-		echo "    - llama2"; \
-		echo "    - mxbai-embed-large"; \
-		echo "    - nomic-embed-text"; \
-		echo "    - all-minilm"; \
-		echo "    - stable-code"; \
-		echo "    - bge-m3"; \
-		echo "    - bge-large"; \
-		echo "    - paraphrase-multilingual"; \
-		echo "    - snowflake-arctic-embed"; \
-		echo "  - Leave blank to default to 'BAAI/bge-small-en-v1.5' via huggingface"; \
-		read -p "> " llm_embedding_model; \
-		echo "embedding_model=\"$$llm_embedding_model\"" >> $(CONFIG_FILE).tmp; \
-		if [ "$$llm_embedding_model" = "llama2" ] || [ "$$llm_embedding_model" = "mxbai-embed-large" ] || [ "$$llm_embedding_model" = "nomic-embed-text" ] || [ "$$llm_embedding_model" = "all-minilm" ] || [ "$$llm_embedding_model" = "stable-code" ]; then \
-			read -p "Enter the local model URL for the embedding model (will set llm.embedding_base_url): " llm_embedding_base_url; \
-				echo "embedding_base_url=\"$$llm_embedding_base_url\"" >> $(CONFIG_FILE).tmp; \
-		elif [ "$$llm_embedding_model" = "azureopenai" ]; then \
-			read -p "Enter the Azure endpoint URL (will overwrite llm.base_url): " llm_base_url; \
-				echo "base_url=\"$$llm_base_url\"" >> $(CONFIG_FILE).tmp; \
-			read -p "Enter the Azure LLM Embedding Deployment Name: " llm_embedding_deployment_name; \
-				echo "embedding_deployment_name=\"$$llm_embedding_deployment_name\"" >> $(CONFIG_FILE).tmp; \
-			read -p "Enter the Azure API Version: " llm_api_version; \
-				echo "api_version=\"$$llm_api_version\"" >> $(CONFIG_FILE).tmp; \
-		fi
-
 
 # Develop in container
 docker-dev:

README.md

@@ -12,7 +12,7 @@
   <a href="https://codecov.io/github/All-Hands-AI/OpenHands?branch=main"><img alt="CodeCov" src="https://img.shields.io/codecov/c/github/All-Hands-AI/OpenHands?style=for-the-badge&color=blue"></a>
   <a href="https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE"><img src="https://img.shields.io/github/license/All-Hands-AI/OpenHands?style=for-the-badge&color=blue" alt="MIT License"></a>
   <br/>
-  <a href="https://join.slack.com/t/openhands-ai/shared_invite/zt-2wkh4pklz-w~h_DVDtEe9H5kyQlcNxVw"><img src="https://img.shields.io/badge/Slack-Join%20Us-red?logo=slack&logoColor=white&style=for-the-badge" alt="Join our Slack community"></a>
+  <a href="https://join.slack.com/t/openhands-ai/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw"><img src="https://img.shields.io/badge/Slack-Join%20Us-red?logo=slack&logoColor=white&style=for-the-badge" alt="Join our Slack community"></a>
   <a href="https://discord.gg/ESHStjSjD4"><img src="https://img.shields.io/badge/Discord-Join%20Us-purple?logo=discord&logoColor=white&style=for-the-badge" alt="Join our Discord community"></a>
   <a href="https://github.com/All-Hands-AI/OpenHands/blob/main/CREDITS.md"><img src="https://img.shields.io/badge/Project-Credits-blue?style=for-the-badge&color=FFE165&logo=github&logoColor=white" alt="Credits"></a>
   <br/>
@@ -39,23 +39,27 @@ Learn more at [docs.all-hands.dev](https://docs.all-hands.dev), or jump to the [
 ## ⚡ Quick Start
 
 The easiest way to run OpenHands is in Docker.
-See the [Installation](https://docs.all-hands.dev/modules/usage/installation) guide for
+See the [Running OpenHands](https://docs.all-hands.dev/modules/usage/installation) guide for
 system requirements and more information.
 
 ```bash
-docker pull docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik
+docker pull docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik
 
 docker run -it --rm --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e LOG_ALL_EVENTS=true \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -v ~/.openhands-state:/.openhands-state \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20
+    docker.all-hands.dev/all-hands-ai/openhands:0.29
 ```
 
+> [!WARNING]
+> On a public network? See our [Hardened Docker Installation](https://docs.all-hands.dev/modules/usage/runtimes/docker#hardened-docker-installation) guide
+> to secure your deployment by restricting network binding and implementing additional security measures.
+
 You'll find OpenHands running at [http://localhost:3000](http://localhost:3000)!
 
 Finally, you'll need a model provider and API key.
@@ -69,7 +73,7 @@ run OpenHands in a scriptable [headless mode](https://docs.all-hands.dev/modules
 interact with it via a [friendly CLI](https://docs.all-hands.dev/modules/usage/how-to/cli-mode),
 or run it on tagged issues with [a github action](https://docs.all-hands.dev/modules/usage/how-to/github-action).
 
-Visit [Installation](https://docs.all-hands.dev/modules/usage/installation) for more information and setup instructions.
+Visit [Running OpenHands](https://docs.all-hands.dev/modules/usage/installation) for more information and setup instructions.
 
 > [!CAUTION]
 > OpenHands is meant to be run by a single user on their local workstation.
@@ -96,7 +100,7 @@ troubleshooting resources, and advanced configuration options.
 OpenHands is a community-driven project, and we welcome contributions from everyone. We do most of our communication
 through Slack, so this is the best place to start, but we also are happy to have you contact us on Discord or Github:
 
-- [Join our Slack workspace](https://join.slack.com/t/openhands-ai/shared_invite/zt-2wkh4pklz-w~h_DVDtEe9H5kyQlcNxVw) - Here we talk about research, architecture, and future development.
+- [Join our Slack workspace](https://join.slack.com/t/openhands-ai/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw) - Here we talk about research, architecture, and future development.
 - [Join our Discord server](https://discord.gg/ESHStjSjD4) - This is a community-run server for general discussion, questions, and feedback.
 - [Read or post Github Issues](https://github.com/All-Hands-AI/OpenHands/issues) - Check out the issues we're working on, or add your own ideas.
 

build.sh

@@ -1,5 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e
 
-cp pyproject.toml poetry.lock openhands
 poetry build -v

config.template.toml

@@ -17,34 +17,46 @@
 #modal_api_token_id = ""
 #modal_api_token_secret = ""
 
+# API key for Daytona
+#daytona_api_key = ""
+
+# Daytona Target
+#daytona_target = ""
+
 # Base path for the workspace
 workspace_base = "./workspace"
 
 # Cache directory path
 #cache_dir = "/tmp/cache"
 
+# Reasoning effort for o1 models (low, medium, high, or not set)
+#reasoning_effort = "medium"
+
 # Debugging enabled
 #debug = false
 
 # Disable color in terminal output
 #disable_color = false
 
-# Enable saving and restoring the session when run from CLI
-#enable_cli_session = false
-
 # Path to store trajectories, can be a folder or a file
 # If it's a folder, the session id will be used as the file name
 #save_trajectory_path="./trajectories"
 
+# Whether to save screenshots in the trajectory
+# The screenshots are encoded and can make trajectory json files very large
+#save_screenshots_in_trajectory = false
+
+# Path to replay a trajectory, must be a file path
+# If provided, trajectory will be loaded and replayed before the
+# agent responds to any user instruction
+#replay_trajectory_path = ""
+
 # File store path
 #file_store_path = "/tmp/file_store"
 
 # File store type
 #file_store = "memory"
 
-# List of allowed file extensions for uploads
-#file_uploads_allowed_extensions = [".*"]
-
 # Maximum file size for uploads, in megabytes
 #file_uploads_max_file_size_mb = 0
 
@@ -67,7 +79,7 @@ workspace_base = "./workspace"
 #run_as_openhands = true
 
 # Runtime environment
-#runtime = "eventstream"
+#runtime = "docker"
 
 # Name of the default agent
 #default_agent = "CodeActAgent"
@@ -81,6 +93,17 @@ workspace_base = "./workspace"
 # List of allowed file extensions for uploads
 #file_uploads_allowed_extensions = [".*"]
 
+# Whether to enable the default LLM summarizing condenser when no condenser is specified in config
+# When true, a LLMSummarizingCondenserConfig will be used as the default condenser
+# When false, a NoOpCondenserConfig (no summarization) will be used
+#enable_default_condenser = true
+
+# Maximum number of concurrent conversations per user
+#max_concurrent_conversations = 3
+
+# Maximum age of conversations in seconds before they are automatically closed
+#conversation_max_age_seconds = 864000  # 10 days
+
 #################################### LLM #####################################
 # Configuration for LLM models (group name starts with 'llm')
 # use 'llm' for the default LLM config
@@ -96,7 +119,7 @@ workspace_base = "./workspace"
 #aws_secret_access_key = ""
 
 # API key to use (For Headless / CLI only -  In Web this is overridden by Session Init)
-api_key = "your-api-key"
+api_key = ""
 
 # API base URL (For Headless / CLI only -  In Web this is overridden by Session Init)
 #base_url = ""
@@ -113,15 +136,6 @@ api_key = "your-api-key"
 # Custom LLM provider
 #custom_llm_provider = ""
 
-# Embedding API base URL
-#embedding_base_url = ""
-
-# Embedding deployment name
-#embedding_deployment_name = ""
-
-# Embedding model to use
-embedding_model = "local"
-
 # Maximum number of characters in an observation's content
 #max_message_chars = 10000
 
@@ -186,8 +200,10 @@ model = "gpt-4o"
 # https://github.com/All-Hands-AI/OpenHands/pull/4711
 #native_tool_calling = None
 
+
+
 [llm.gpt4o-mini]
-api_key = "your-api-key"
+api_key = ""
 model = "gpt-4o"
 
 
@@ -199,33 +215,28 @@ model = "gpt-4o"
 ##############################################################################
 [agent]
 
-# whether the browsing tool is enabled
+# Whether the browsing tool is enabled
 codeact_enable_browsing = true
 
-# whether the LLM draft editor is enabled
+# Whether the LLM draft editor is enabled
 codeact_enable_llm_editor = false
 
-# whether the IPython tool is enabled
+# Whether the IPython tool is enabled
 codeact_enable_jupyter = true
 
-# Name of the micro agent to use for this agent
-#micro_agent_name = ""
-
-# Memory enabled
-#memory_enabled = false
-
-# Memory maximum threads
-#memory_max_threads = 3
-
 # LLM config group to use
 #llm_config = 'your-llm-config-group'
 
-# Whether to use microagents at all
-#use_microagents = true
+# Whether to use prompt extension (e.g., microagent, repo/runtime info) at all
+#enable_prompt_extensions = true
 
 # List of microagents to disable
 #disabled_microagents = []
 
+# Whether history should be truncated to continue the session when hitting LLM context
+# length limit
+enable_history_truncation = true
+
 [agent.RepoExplorerAgent]
 # Example: use a cheaper model for RepoExplorerAgent to reduce cost, especially
 # useful when an agent doesn't demand high quality but uses a lot of tokens
@@ -247,7 +258,7 @@ llm_config = 'gpt3'
 # Use host network
 #use_host_network = false
 
-# runtime extra build args
+# Runtime extra build args
 #runtime_extra_build_args = ["--network=host", "--add-host=host.docker.internal:host-gateway"]
 
 # Enable auto linting after editing
@@ -265,6 +276,33 @@ llm_config = 'gpt3'
 # BrowserGym environment to use for evaluation
 #browsergym_eval_env = ""
 
+# Platform to use for building the runtime image (e.g., "linux/amd64")
+#platform = ""
+
+# Force rebuild of runtime image even if it exists
+#force_rebuild_runtime = false
+
+# Runtime container image to use (if not provided, will be built from base_container_image)
+#runtime_container_image = ""
+
+# Keep runtime alive after session ends
+#keep_runtime_alive = false
+
+# Pause closed runtimes instead of stopping them
+#pause_closed_runtimes = false
+
+# Delay in seconds before closing idle runtimes
+#close_delay = 300
+
+# Remove all containers when stopping the runtime
+#rm_all_containers = false
+
+# Enable GPU support in the runtime
+#enable_gpu = false
+
+# Additional Docker runtime kwargs
+#docker_runtime_kwargs = {}
+
 #################################### Security ###################################
 # Configuration for security features
 ##############################################################################
@@ -276,6 +314,72 @@ llm_config = 'gpt3'
 # The security analyzer to use (For Headless / CLI only -  In Web this is overridden by Session Init)
 #security_analyzer = ""
 
+# Whether to enable security analyzer
+#enable_security_analyzer = false
+
+#################################### Condenser #################################
+# Condensers control how conversation history is managed and compressed when
+# the context grows too large. Each agent uses one condenser configuration.
+##############################################################################
+[condenser]
+# The type of condenser to use. Available options:
+# - "noop": No condensing, keeps full history (default)
+# - "observation_masking": Keeps full event structure but masks older observations
+# - "recent": Keeps only recent events and discards older ones
+# - "llm": Uses an LLM to summarize conversation history
+# - "amortized": Intelligently forgets older events while preserving important context
+# - "llm_attention": Uses an LLM to prioritize most relevant context
+type = "noop"
+
+# Examples for each condenser type (uncomment and modify as needed):
+
+# 1. NoOp Condenser - No additional settings needed
+#type = "noop"
+
+# 2. Observation Masking Condenser
+#type = "observation_masking"
+# Number of most-recent events where observations will not be masked
+#attention_window = 100
+
+# 3. Recent Events Condenser
+#type = "recent"
+# Number of initial events to always keep (typically includes task description)
+#keep_first = 1
+# Maximum number of events to keep in history
+#max_events = 100
+
+# 4. LLM Summarizing Condenser
+#type = "llm"
+# Reference to an LLM config to use for summarization
+#llm_config = "condenser"
+# Number of initial events to always keep (typically includes task description)
+#keep_first = 1
+# Maximum size of history before triggering summarization
+#max_size = 100
+
+# 5. Amortized Forgetting Condenser
+#type = "amortized"
+# Number of initial events to always keep (typically includes task description)
+#keep_first = 1
+# Maximum size of history before triggering forgetting
+#max_size = 100
+
+# 6. LLM Attention Condenser
+#type = "llm_attention"
+# Reference to an LLM config to use for attention scoring
+#llm_config = "condenser"
+# Number of initial events to always keep (typically includes task description)
+#keep_first = 1
+# Maximum size of history before triggering attention mechanism
+#max_size = 100
+
+# Example of a custom LLM configuration for condensers that require an LLM
+# If not provided, it falls back to the default LLM
+#[llm.condenser]
+#model = "gpt-4o"
+#temperature = 0.1
+#max_tokens = 1024
+
 #################################### Eval ####################################
 # Configuration for the evaluation, please refer to the specific evaluation
 # plugin for the available options

containers/app/Dockerfile

@@ -26,7 +26,7 @@ RUN apt-get update -y \
 
 COPY ./pyproject.toml ./poetry.lock ./
 RUN touch README.md
-RUN export POETRY_CACHE_DIR && poetry install --without evaluation,llama-index --no-root && rm -rf $POETRY_CACHE_DIR
+RUN export POETRY_CACHE_DIR && poetry install --without evaluation --no-root && rm -rf $POETRY_CACHE_DIR
 
 FROM python:3.12.3-slim AS openhands-app
 

containers/build.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -eo pipefail
 
 # Initialize variables with default values

containers/dev/compose.yml

@@ -11,7 +11,7 @@ services:
       - BACKEND_HOST=${BACKEND_HOST:-"0.0.0.0"}
       - SANDBOX_API_HOSTNAME=host.docker.internal
       #
-      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-ghcr.io/all-hands-ai/runtime:0.20-nikolaik}
+      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-ghcr.io/all-hands-ai/runtime:0.29-nikolaik}
       - SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234}
       - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
     ports:

containers/dev/dev.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -o pipefail
 
 function get_docker() {

dev_config/python/ruff.toml

@@ -24,3 +24,6 @@ inline-quotes = "single"
 
 [format]
 quote-style = "single"
+
+[lint.flake8-bugbear]
+extend-immutable-calls = ["Depends", "fastapi.Depends", "fastapi.params.Depends"]

docker-compose.yml

@@ -7,7 +7,7 @@ services:
     image: openhands:latest
     container_name: openhands-app-${DATE:-}
     environment:
-      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik}
+      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik}
       #- SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234} # enable this only if you want a specific non-root sandbox user but you will have to manually adjust permissions of openhands-state for this user
       - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
     ports:

docs/DOC_STYLE_GUIDE.md

@@ -46,3 +46,11 @@ docker run -it \
     -e THAT=that
     ...
 ```
+
+### Referring to UI Elements
+
+When referencing UI elements, use ``.
+
+Example:
+1. Toggle the `Advanced` option
+2. Enter your model in the `Custom Model` textbox.

docs/README.md

@@ -1,21 +1,32 @@
-# Website
+# OpenHands Documentation
 
-This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
+This website is built using [Docusaurus](https://docusaurus.io/).
+
+When published, the content will be published at https://docs.all-hands.dev/.
 
 ### Installation
 
-```
+```bash
+$ cd docs
 $ yarn
 ```
 
 ### Local Development
 
 ```
-$ yarn start
+$ yarn start # for the default English version
 ```
 
 This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
 
+Alternatively, you can pass a `--locale` argument to render a specific language in dev mode as in:
+
+```
+$ yarn start --locale pt-BR # for the Brazilian Portuguese version
+$ yarn start --locale fr # for the French version
+$ yarn start --locale zh-Hans # for the Chinese Han (simplified variant) version
+```
+
 ### Build
 
 ```
@@ -24,18 +35,26 @@ $ yarn build
 
 This command generates static content into the `build` directory and can be served using any static contents hosting service.
 
+It compiles all languages.
+
 ### Deployment
 
-Using SSH:
+Open a new pull request and - when it is merged - the [deploy-docs](.github/workflows/deploy-docs.yml) GH action will take care of everything else.
 
-```
-$ USE_SSH=true yarn deploy
+## Automatic Translations
+
+Translations can be automatically updated when the original English content changes, this is done by the script [`translation_updater.py`](./translation_updater.py).
+
+From the root of the repository, you can run the following:
+
+```bash
+$ export ANTHROPIC_API_KEY=<your_api_key>
+$ poetry run python docs/translation_updater.py
+# ...
+# Change detected in docs/modules/usage/getting-started.mdx
+# translating... docs/modules/usage/getting-started.mdx pt-BR
+# translation done
+# ...
 ```
 
-Not using SSH:
-
-```
-$ GIT_USER=<Your GitHub username> yarn deploy
-```
-
-If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.
+This process uses `claude-3-opus-20240229` as base model and each language consumes at least ~30k input tokens and ~35k output tokens.

docs/docusaurus.config.ts

@@ -1,30 +1,30 @@
-import type * as Preset from "@docusaurus/preset-classic";
-import type { Config } from "@docusaurus/types";
-import { themes as prismThemes } from "prism-react-renderer";
+import type * as Preset from '@docusaurus/preset-classic';
+import type { Config } from '@docusaurus/types';
+import { themes as prismThemes } from 'prism-react-renderer';
 
 const config: Config = {
-  title: "OpenHands",
-  tagline: "Code Less, Make More",
-  favicon: "img/logo-square.png",
+  title: 'OpenHands',
+  tagline: 'Code Less, Make More',
+  favicon: 'img/logo-square.png',
 
   // Set the production url of your site here
-  url: "https://docs.all-hands.dev",
-  baseUrl: "/",
+  url: 'https://docs.all-hands.dev',
+  baseUrl: '/',
 
   // GitHub pages deployment config.
-  organizationName: "All-Hands-AI",
-  projectName: "OpenHands",
+  organizationName: 'All-Hands-AI',
+  projectName: 'OpenHands',
   trailingSlash: false,
 
-  onBrokenLinks: "throw",
-  onBrokenMarkdownLinks: "warn",
+  onBrokenLinks: 'throw',
+  onBrokenMarkdownLinks: 'warn',
 
   // Even if you don't use internationalization, you can use this field to set
   // useful metadata like html lang. For example, if your site is Chinese, you
   // may want to replace "en" with "zh-Hans".
   i18n: {
     defaultLocale: 'en',
-    locales: ['en', 'fr', 'zh-Hans'],
+    locales: ['en', 'fr', 'zh-Hans', 'pt-BR'],
     localeConfigs: {
       en: {
         htmlLang: 'en-GB',
@@ -38,62 +38,56 @@ const config: Config = {
   themes: ['@docusaurus/theme-mermaid'],
   presets: [
     [
-      "classic",
+      'classic',
       {
         docs: {
-          path: "modules",
-          routeBasePath: "modules",
-          sidebarPath: "./sidebars.ts",
+          path: 'modules',
+          routeBasePath: 'modules',
+          sidebarPath: './sidebars.ts',
           exclude: [
             // '**/_*.{js,jsx,ts,tsx,md,mdx}',
             // '**/_*/**',
-            "**/*.test.{js,jsx,ts,tsx}",
-            "**/__tests__/**",
+            '**/*.test.{js,jsx,ts,tsx}',
+            '**/__tests__/**',
           ],
         },
         blog: {
           showReadingTime: true,
         },
         theme: {
-          customCss: "./src/css/custom.css",
+          customCss: './src/css/custom.css',
         },
       } satisfies Preset.Options,
     ],
   ],
   themeConfig: {
-    image: "img/docusaurus.png",
+    image: 'img/docusaurus.png',
     navbar: {
-      title: "OpenHands",
+      title: 'OpenHands',
       logo: {
-        alt: "OpenHands",
-        src: "img/logo.png",
+        alt: 'OpenHands',
+        src: 'img/logo.png',
       },
       items: [
         {
-          type: "docSidebar",
-          sidebarId: "docsSidebar",
-          position: "left",
-          label: "User Guides",
-        },
-        {
-          type: "docSidebar",
-          sidebarId: "apiSidebar",
-          position: "left",
-          label: "Python API",
+          type: 'docSidebar',
+          sidebarId: 'docsSidebar',
+          position: 'left',
+          label: 'User Guides',
         },
         {
           type: 'localeDropdown',
           position: 'left',
         },
         {
-          href: "https://all-hands.dev",
-          label: "Company",
-          position: "right",
+          href: 'https://all-hands.dev',
+          label: 'Company',
+          position: 'right',
         },
         {
-          href: "https://github.com/All-Hands-AI/OpenHands",
-          label: "GitHub",
-          position: "right",
+          href: 'https://github.com/All-Hands-AI/OpenHands',
+          label: 'GitHub',
+          position: 'right',
         },
       ],
     },

docs/i18n/fr/code.json

@@ -402,5 +402,26 @@
   "theme.unlistedContent.message": {
     "message": "Cette page n'est pas répertoriée. Les moteurs de recherche ne l'indexeront pas, et seuls les utilisateurs ayant un lien direct peuvent y accéder.",
     "description": "The unlisted content banner message"
+  },
+  "Use AI to tackle the toil in your backlog. Our agents have all the same tools as a human developer: they can modify code, run commands, browse the web, call APIs, and yes-even copy code snippets from StackOverflow.": {
+    "message": "Utilisez l'IA pour gérer les tâches répétitives de votre backlog. Nos agents disposent des mêmes outils qu'un développeur humain : ils peuvent modifier du code, exécuter des commandes, naviguer sur le web, appeler des API et même copier des extraits de code depuis StackOverflow."
+  },
+  "Get started with OpenHands.": {
+    "message": "Commencer avec OpenHands"
+  },
+  "Most Popular Links": {
+    "message": "Liens Populaires"
+  },
+  "Customizing OpenHands to a repository": {
+    "message": "Personnaliser OpenHands pour un dépôt"
+  },
+  "Integrating OpenHands with Github": {
+    "message": "Intégrer OpenHands avec Github"
+  },
+  "Recommended models to use": {
+    "message": "Modèles recommandés"
+  },
+  "Connecting OpenHands to your filesystem": {
+    "message": "Connecter OpenHands à votre système de fichiers"
   }
 }

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/architecture/runtime.md

@@ -1,8 +1,8 @@
 
 
-# 📦 Runtime EventStream
+# 📦 Runtime Docker
 
-Le Runtime EventStream d'OpenHands est le composant principal qui permet l'exécution sécurisée et flexible des actions des agents d'IA.
+Le Runtime Docker d'OpenHands est le composant principal qui permet l'exécution sécurisée et flexible des actions des agents d'IA.
 Il crée un environnement en bac à sable (sandbox) en utilisant Docker, où du code arbitraire peut être exécuté en toute sécurité sans risquer le système hôte.
 
 ## Pourquoi avons-nous besoin d'un runtime en bac à sable ?

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/configuration-options.md

@@ -11,41 +11,39 @@ la priorité.
 
 # Table des matières
 
-1. [Configuration de base](#configuration-de-base)
-   - [Clés API](#clés-api)
-   - [Espace de travail](#espace-de-travail)
-   - [Débogage et journalisation](#débogage-et-journalisation)
-   - [Gestion des sessions](#gestion-des-sessions)
-   - [Trajectoires](#trajectoires)
-   - [Stockage de fichiers](#stockage-de-fichiers)
-   - [Gestion des tâches](#gestion-des-tâches)
-   - [Configuration du bac à sable](#configuration-du-bac-à-sable)
-   - [Divers](#divers)
-2. [Configuration LLM](#configuration-llm)
-   - [Informations d'identification AWS](#informations-didentification-aws)
-   - [Configuration de l'API](#configuration-de-lapi)
-   - [Fournisseur LLM personnalisé](#fournisseur-llm-personnalisé)
+1. [Configuration de base](#core-configuration)
+   - [Clés API](#api-keys)
+   - [Espace de travail](#workspace)
+   - [Débogage et journalisation](#debugging-and-logging)
+   - [Trajectoires](#trajectories)
+   - [Stockage de fichiers](#file-store)
+   - [Gestion des tâches](#task-management)
+   - [Configuration du bac à sable](#sandbox-configuration)
+   - [Divers](#miscellaneous)
+2. [Configuration LLM](#llm-configuration)
+   - [Informations d'identification AWS](#aws-credentials)
+   - [Configuration de l'API](#api-configuration)
+   - [Fournisseur LLM personnalisé](#custom-llm-provider)
    - [Embeddings](#embeddings)
-   - [Gestion des messages](#gestion-des-messages)
-   - [Sélection du modèle](#sélection-du-modèle)
-   - [Nouvelles tentatives](#nouvelles-tentatives)
-   - [Options avancées](#options-avancées)
-3. [Configuration de l'agent](#configuration-de-lagent)
-   - [Configuration du micro-agent](#configuration-du-micro-agent)
-   - [Configuration de la mémoire](#configuration-de-la-mémoire)
-   - [Configuration LLM](#configuration-llm-2)
-   - [Configuration de l'espace d'action](#configuration-de-lespace-daction)
-   - [Utilisation du micro-agent](#utilisation-du-micro-agent)
-4. [Configuration du bac à sable](#configuration-du-bac-à-sable-2)
-   - [Exécution](#exécution)
-   - [Image de conteneur](#image-de-conteneur)
-   - [Mise en réseau](#mise-en-réseau)
-   - [Linting et plugins](#linting-et-plugins)
-   - [Dépendances et environnement](#dépendances-et-environnement)
-   - [Évaluation](#évaluation)
-5. [Configuration de sécurité](#configuration-de-sécurité)
-   - [Mode de confirmation](#mode-de-confirmation)
-   - [Analyseur de sécurité](#analyseur-de-sécurité)
+   - [Gestion des messages](#message-handling)
+   - [Sélection du modèle](#model-selection)
+   - [Nouvelles tentatives](#retrying)
+   - [Options avancées](#advanced-options)
+3. [Configuration de l'agent](#agent-configuration)
+   - [Configuration de la mémoire](#memory-configuration)
+   - [Configuration LLM](#llm-configuration-1)
+   - [Configuration de l'espace d'action](#actionspace-configuration)
+   - [Utilisation du micro-agent](#microagent-usage)
+4. [Configuration du bac à sable](#sandbox-configuration-1)
+   - [Exécution](#execution)
+   - [Image de conteneur](#container-image)
+   - [Mise en réseau](#networking)
+   - [Linting et plugins](#linting-and-plugins)
+   - [Dépendances et environnement](#dependencies-and-environment)
+   - [Évaluation](#evaluation)
+5. [Configuration de sécurité](#security-configuration)
+   - [Mode de confirmation](#confirmation-mode)
+   - [Analyseur de sécurité](#security-analyzer)
 
 ---
 
@@ -163,7 +161,7 @@ Les options de configuration de base sont définies dans la section `[core]` du
 
 - `runtime`
   - Type : `str`
-  - Valeur par défaut : `"eventstream"`
+  - Valeur par défaut : `"docker"`
   - Description : Environnement d'exécution
 
 - `default_agent`
@@ -333,12 +331,6 @@ Pour les configurations de développement, vous pouvez également définir des c
 
 Les options de configuration de l'agent sont définies dans les sections `[agent]` et `[agent.<agent_name>]` du fichier `config.toml`.
 
-**Configuration du micro-agent**
-- `micro_agent_name`
-  - Type : `str`
-  - Valeur par défaut : `""`
-  - Description : Nom du micro-agent à utiliser pour cet agent
-
 **Configuration de la mémoire**
 - `memory_enabled`
   - Type : `bool`
@@ -373,7 +365,7 @@ Les options de configuration de l'agent sont définies dans les sections `[agent
   - Description : Si l'éditeur LLM est activé dans l'espace d'action (fonctionne uniquement avec l'appel de fonction)
 
 **Utilisation du micro-agent**
-- `use_microagents`
+- `enable_prompt_extensions`
   - Type : `bool`
   - Valeur par défaut : `true`
   - Description : Indique si l'utilisation des micro-agents est activée ou non

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/custom_sandbox_guide.md

@@ -42,10 +42,11 @@ Créez un fichier ```config.toml``` dans le répertoire OpenHands et entrez ces
 [core]
 workspace_base="./workspace"
 run_as_openhands=true
-sandbox_base_container_image="image_personnalisée"
+[sandbox]
+base_container_image="image_personnalisée"
 ```
 
-> Assurez-vous que ```sandbox_base_container_image``` est défini sur le nom de votre image personnalisée précédente.
+> Assurez-vous que ```base_container_image``` est défini sur le nom de votre image personnalisée précédente.
 
 ## Exécution
 
@@ -82,20 +83,17 @@ dockerfile_content = (
 ## Dépannage / Erreurs
 
 ### Erreur: ```useradd: UID 1000 est non unique```
-Si vous voyez cette erreur dans la sortie de la console, il s'agit du fait que OpenHands essaie de créer le utilisateur openhands dans le sandbox avec un ID d'utilisateur de 1000, cependant cet ID d'utilisateur est déjà utilisé dans l'image (pour une raison inconnue). Pour résoudre ce problème, changez la valeur du champ sandbox_user_id dans le fichier config.toml en une valeur différente:
+Si vous voyez cette erreur dans la sortie de la console, il s'agit du fait que OpenHands essaie de créer le utilisateur openhands dans le sandbox avec un ID d'utilisateur de 1000, cependant cet ID d'utilisateur est déjà utilisé dans l'image (pour une raison inconnue). Pour résoudre ce problème, changez la valeur du champ user_id dans le fichier config.toml en une valeur différente:
 
 ```toml
 [core]
 workspace_base="./workspace"
 run_as_openhands=true
-sandbox_base_container_image="image_personnalisée"
-sandbox_user_id="1001"
+[sandbox]
+base_container_image="image_personnalisée"
+user_id="1001"
 ```
 
 ### Erreurs de port d'utilisation
 
 Si vous voyez un message d'erreur indiquant que le port est utilisé ou indisponible, essayez de supprimer toutes les containers docker en cours d'exécution (exécutez `docker ps` et `docker rm` des containers concernés) puis ré-exécutez ```make run```
-
-## Discuter
-
-Pour d'autres problèmes ou questions rejoignez le [Slack](https://join.slack.com/t/openhands-ai/shared_invite/zt-2wkh4pklz-w~h_DVDtEe9H5kyQlcNxVw) ou le [Discord](https://discord.gg/ESHStjSjD4) et demandez!

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/how-to/cli-mode.md

@@ -52,7 +52,7 @@ LLM_API_KEY="sk_test_12345"
 ```bash
 docker run -it \
     --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e SANDBOX_USER_ID=$(id -u) \
     -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
     -e LLM_API_KEY=$LLM_API_KEY \
@@ -61,7 +61,7 @@ docker run -it \
     -v /var/run/docker.sock:/var/run/docker.sock \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app-$(date +%Y%m%d%H%M%S) \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20 \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29 \
     python -m openhands.core.cli
 ```
 

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/how-to/custom-sandbox-guide.md

@@ -44,12 +44,13 @@ Tout d'abord, assurez-vous de pouvoir exécuter OpenHands en suivant les instruc
 
 ### Spécifier l'Image de Base du Sandbox
 
-Dans le fichier `config.toml` dans le répertoire OpenHands, définissez `sandbox_base_container_image` sur l'image que vous souhaitez utiliser. Cela peut être une image que vous avez déjà extraite ou une que vous avez construite :
+Dans le fichier `config.toml` dans le répertoire OpenHands, définissez `base_container_image` sur l'image que vous souhaitez utiliser. Cela peut être une image que vous avez déjà extraite ou une que vous avez construite :
 
 ```bash
 [core]
 ...
-sandbox_base_container_image="custom-image"
+[sandbox]
+base_container_image="custom-image"
 ```
 
 ### Exécution

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/how-to/evaluation-harness.md

@@ -114,7 +114,7 @@ Pour créer un workflow d'évaluation pour votre benchmark, suivez ces étapes :
    def get_config(instance: pd.Series, metadata: EvalMetadata) -> AppConfig:
        config = AppConfig(
            default_agent=metadata.agent_class,
-           runtime='eventstream',
+           runtime='docker',
            max_iterations=metadata.max_iterations,
            sandbox=SandboxConfig(
                base_container_image='your_container_image',

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/how-to/headless-mode.md

@@ -46,7 +46,7 @@ LLM_API_KEY="sk_test_12345"
 ```bash
 docker run -it \
     --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e SANDBOX_USER_ID=$(id -u) \
     -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
     -e LLM_API_KEY=$LLM_API_KEY \
@@ -56,6 +56,6 @@ docker run -it \
     -v /var/run/docker.sock:/var/run/docker.sock \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app-$(date +%Y%m%d%H%M%S) \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20 \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29 \
     python -m openhands.core.main -t "write a bash script that prints hi" --no-auto-continue
 ```

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/installation.mdx

@@ -13,16 +13,16 @@
 La façon la plus simple d'exécuter OpenHands est avec Docker.
 
 ```bash
-docker pull docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik
+docker pull docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik
 
 docker run -it --rm --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e LOG_ALL_EVENTS=true \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20
+    docker.all-hands.dev/all-hands-ai/openhands:0.29
 ```
 
 Vous pouvez également exécuter OpenHands en mode [headless scriptable](https://docs.all-hands.dev/modules/usage/how-to/headless-mode), en tant que [CLI interactive](https://docs.all-hands.dev/modules/usage/how-to/cli-mode), ou en utilisant l'[Action GitHub OpenHands](https://docs.all-hands.dev/modules/usage/how-to/github-action).

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/intro.mdx

@@ -42,7 +42,7 @@ Explorez le code source d'OpenHands sur [GitHub](https://github.com/All-Hands-AI
   />
 </a>
 <br></br>
-<a href="https://join.slack.com/t/openhands-ai/shared_invite/zt-2wkh4pklz-w~h_DVDtEe9H5kyQlcNxVw">
+<a href="https://join.slack.com/t/openhands-ai/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw">
   <img
     src="https://img.shields.io/badge/Slack-Join%20Us-red?logo=slack&logoColor=white&style=for-the-badge"
     alt="Join our Slack community"

docs/i18n/fr/docusaurus-plugin-content-docs/current/usage/runtimes.md

@@ -13,7 +13,7 @@ C'est le Runtime par défaut qui est utilisé lorsque vous démarrez OpenHands.
 
 ```
 docker run # ...
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -v /var/run/docker.sock:/var/run/docker.sock \
     # ...
 ```

docs/i18n/pt-BR/code.json

@@ -0,0 +1,53 @@
+{
+    "footer.title": {
+        "message": "OpenHands"
+    },
+    "footer.docs": {
+        "message": "Documentação"
+    },
+    "footer.community": {
+        "message": "Comunidade"
+    },
+    "footer.copyright": {
+        "message": "© {year} OpenHands"
+    },
+    "faq.title": {
+        "message": "Perguntas Frequentes",
+        "description": "FAQ Title"
+    },
+    "faq.description": {
+        "message": "Perguntas Frequentes"
+    },
+    "faq.section.title.1": {
+        "message": "O que é o OpenHands?",
+        "description": "First Section Title"
+    },
+    "faq.section.highlight": {
+        "message": "OpenHands",
+        "description": "Highlight Text"
+    },
+    "faq.section.description.1": {
+        "message": "é um engenheiro de software autônomo que pode resolver tarefas de engenharia de software e navegação web a qualquer momento. Pode executar consultas de ciência de dados, como \"Encontrar o número de pull requests no repositório OpenHands nos últimos meses\", e tarefas de engenharia de software, como \"Por favor, adicione testes a este arquivo e verifique se todos os testes passam. Se não, corrija o arquivo.\"",
+        "description": "Description for OpenHands"
+    },
+    "faq.section.description.2": {
+        "message": "Além disso, o OpenHands é uma plataforma e comunidade para desenvolvedores de agentes que desejam testar e avaliar novos agentes.",
+        "description": "Further Description for OpenHands"
+    },
+    "faq.section.title.2": {
+        "message": "Suporte",
+        "description": "Support Section Title"
+    },
+    "faq.section.support.answer": {
+        "message": "Se você encontrar um problema que outros usuários também possam ter, por favor, relate-o em {githubLink}. Se você estiver tendo dificuldades com a instalação ou tiver perguntas gerais, junte-se a nós no {discordLink} ou {slackLink}.",
+        "description": "Support Answer"
+    },
+    "faq.section.title.3": {
+        "message": "Como resolver um problema no GitHub com o OpenHands?",
+        "description": "GitHub Issue Section Title"
+    },
+    "faq.section.github.steps.intro": {
+        "message": "Para resolver um problema no GitHub usando o OpenHands, envie um comando ao OpenHands pedindo para seguir etapas como as seguintes:",
+        "description": "GitHub Steps Introduction"
+    }
+}

docs/i18n/pt-BR/docusaurus-plugin-content-blog/options.json

@@ -0,0 +1,14 @@
+{
+  "title": {
+    "message": "Blog",
+    "description": "O título do blog usado para SEO"
+  },
+  "description": {
+    "message": "Blog",
+    "description": "A descrição do blog usada para SEO"
+  },
+  "sidebar.title": {
+    "message": "Artigos recentes",
+    "description": "A descrição para a barra lateral esquerda"
+  }
+}

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current.json

@@ -0,0 +1,18 @@
+{
+    "version.label": {
+        "message": "Atual",
+        "description": "The label for version current"
+    },
+    "sidebar.docsSidebar.category.🤖 Backends LLM": {
+        "message": "🤖 Backends LLM",
+        "description": "The label for category 🤖 Backends LLM in sidebar docsSidebar"
+    },
+    "sidebar.docsSidebar.category.🚧 Dépannage": {
+        "message": "🚧 Solução de Problemas",
+        "description": "The label for category 🚧 Dépannage in sidebar docsSidebar"
+    },
+    "sidebar.apiSidebar.category.Backend": {
+        "message": "Backend",
+        "description": "The label for category Backend in sidebar apiSidebar"
+    }
+}

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/python/python.md

@@ -0,0 +1,3 @@
+# Python Docs
+
+Docs will appear here after deployment.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/python/sidebar.json

@@ -0,0 +1,5 @@
+{
+  "items": ["python/python"],
+  "label": "Backend",
+  "type": "category"
+}

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/about.md

@@ -0,0 +1,25 @@
+# Sobre o OpenHands
+
+## Estratégia de Pesquisa
+
+Alcançar a replicação completa de aplicações de nível de produção com LLMs é um esforço complexo. Nossa estratégia envolve:
+
+- **Pesquisa Técnica Central:** Foco em pesquisa fundamental para entender e aprimorar os aspectos técnicos da geração e manipulação de código.
+- **Planejamento de Tarefas:** Desenvolvimento de capacidades para detecção de bugs, gerenciamento de codebase e otimização.
+- **Avaliação:** Estabelecimento de métricas de avaliação abrangentes para melhor entender e aprimorar nossos agentes.
+
+## Agente Padrão
+
+Nosso Agente padrão atualmente é o [CodeActAgent](agents), que é capaz de gerar código e lidar com arquivos.
+
+## Construído Com
+
+O OpenHands é construído usando uma combinação de poderosos frameworks e bibliotecas, fornecendo uma base robusta para seu desenvolvimento. Aqui estão as principais tecnologias usadas no projeto:
+
+![FastAPI](https://img.shields.io/badge/FastAPI-black?style=for-the-badge) ![uvicorn](https://img.shields.io/badge/uvicorn-black?style=for-the-badge) ![LiteLLM](https://img.shields.io/badge/LiteLLM-black?style=for-the-badge) ![Docker](https://img.shields.io/badge/Docker-black?style=for-the-badge) ![Ruff](https://img.shields.io/badge/Ruff-black?style=for-the-badge) ![MyPy](https://img.shields.io/badge/MyPy-black?style=for-the-badge) ![LlamaIndex](https://img.shields.io/badge/LlamaIndex-black?style=for-the-badge) ![React](https://img.shields.io/badge/React-black?style=for-the-badge)
+
+Por favor, note que a seleção dessas tecnologias está em andamento, e tecnologias adicionais podem ser adicionadas ou as existentes podem ser removidas à medida que o projeto evolui. Nós nos esforçamos para adotar as ferramentas mais adequadas e eficientes para aprimorar as capacidades do OpenHands.
+
+## Licença
+
+Distribuído sob a [Licença](https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE) MIT.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/agents.md

@@ -0,0 +1,23 @@
+# 🧠 Agente Principal e Capacidades
+
+## CodeActAgent
+
+### Descrição
+
+Este agente implementa a ideia do CodeAct ([artigo](https://arxiv.org/abs/2402.01030), [tweet](https://twitter.com/xingyaow_/status/1754556835703751087)) que consolida as **ações** dos agentes LLM em um espaço de ação de **código** unificado para _simplicidade_ e _desempenho_.
+
+A ideia conceitual é ilustrada abaixo. A cada turno, o agente pode:
+
+1. **Conversar**: Comunicar-se com humanos em linguagem natural para pedir esclarecimentos, confirmações, etc.
+2. **CodeAct**: Optar por executar a tarefa executando código
+
+- Executar qualquer comando Linux `bash` válido
+- Executar qualquer código `Python` válido com [um interpretador Python interativo](https://ipython.org/). Isso é simulado através do comando `bash`, veja o sistema de plugins abaixo para mais detalhes.
+
+![image](https://github.com/All-Hands-AI/OpenHands/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
+
+### Demonstração
+
+https://github.com/All-Hands-AI/OpenHands/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
+
+_Exemplo do CodeActAgent com `gpt-4-turbo-2024-04-09` realizando uma tarefa de ciência de dados (regressão linear)_.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/architecture/backend.mdx

@@ -0,0 +1,58 @@
+# 🏛️ Arquitetura do Sistema
+
+<div style={{ textAlign: 'center' }}>
+  <img
+    src="https://github.com/All-Hands-AI/OpenHands/assets/16201837/97d747e3-29d8-4ccb-8d34-6ad1adb17f38"
+    alt="Diagrama da Arquitetura do Sistema OpenHands 4 de julho de 2024"
+  />
+  <p>
+    <em>Diagrama da Arquitetura do Sistema OpenHands (4 de julho de 2024)</em>
+  </p>
+</div>
+
+Esta é uma visão geral de alto nível da arquitetura do sistema. O sistema é dividido em dois componentes principais: o frontend e o backend. O frontend é responsável por lidar com as interações do usuário e exibir os resultados. O backend é responsável por lidar com a lógica de negócios e executar os agentes.
+
+# Arquitetura do Frontend {#frontend-architecture-en}
+
+![system_architecture.svg](/img/system_architecture.svg)
+
+Esta visão geral é simplificada para mostrar os principais componentes e suas interações. Para uma visão mais detalhada da arquitetura do backend, consulte a seção Arquitetura do Backend abaixo.
+
+# Arquitetura do Backend {#backend-architecture-en}
+
+_**Aviso**: A arquitetura do backend é um trabalho em andamento e está sujeita a alterações. O diagrama a seguir mostra a arquitetura atual do backend com base no commit mostrado no rodapé do diagrama._
+
+![backend_architecture.svg](/img/backend_architecture.svg)
+
+<details>
+  <summary>Atualizando este Diagrama</summary>
+  <div>
+    A geração do diagrama da arquitetura do backend é parcialmente automatizada.
+    O diagrama é gerado a partir das type hints no código usando a ferramenta py2puml.
+    O diagrama é então revisado manualmente, ajustado e exportado para PNG e SVG.
+
+    ## Pré-requisitos
+
+    - Ambiente python em execução no qual o openhands é executável
+    (de acordo com as instruções no arquivo README.md na raiz do repositório)
+    - [py2puml](https://github.com/lucsorel/py2puml) instalado
+
+## Passos
+
+1.  Gere automaticamente o diagrama executando o seguinte comando na raiz do repositório:
+    `py2puml openhands openhands > docs/architecture/backend_architecture.puml`
+
+2.  Abra o arquivo gerado em um editor PlantUML, por exemplo, Visual Studio Code com a extensão PlantUML ou [PlantText](https://www.planttext.com/)
+
+3.  Revise o PUML gerado e faça todos os ajustes necessários no diagrama (adicione partes ausentes, corrija erros, melhore o posicionamento).
+    _py2puml cria o diagrama com base nas type hints no código, portanto, type hints ausentes ou incorretas podem resultar em um diagrama incompleto ou incorreto._
+
+4.  Revise a diferença entre o novo diagrama e o anterior e verifique manualmente se as alterações estão corretas.
+    _Certifique-se de não remover partes que foram adicionadas manualmente ao diagrama no passado e ainda são relevantes._
+
+5.  Adicione o hash do commit que foi usado para gerar o diagrama no rodapé do diagrama.
+
+6.  Exporte o diagrama como arquivos PNG e SVG e substitua os diagramas existentes no diretório `docs/architecture`. Isso pode ser feito com (por exemplo, [PlantText](https://www.planttext.com/))
+
+  </div>
+</details>

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/architecture/runtime.md

@@ -0,0 +1,134 @@
+# 📦 Docker Runtime
+
+O OpenHands Docker Runtime é o componente principal que permite a execução segura e flexível das ações do agente de IA.
+Ele cria um ambiente isolado usando o Docker, onde código arbitrário pode ser executado com segurança sem arriscar o sistema host.
+
+## Por que precisamos de um runtime isolado?
+
+O OpenHands precisa executar código arbitrário em um ambiente seguro e isolado por várias razões:
+
+1. Segurança: Executar código não confiável pode representar riscos significativos para o sistema host. Um ambiente isolado impede que código malicioso acesse ou modifique os recursos do sistema host
+2. Consistência: Um ambiente isolado garante que a execução do código seja consistente em diferentes máquinas e configurações, eliminando problemas do tipo "funciona na minha máquina"
+3. Controle de Recursos: O isolamento permite um melhor controle sobre a alocação e uso de recursos, evitando que processos descontrolados afetem o sistema host
+4. Isolamento: Diferentes projetos ou usuários podem trabalhar em ambientes isolados sem interferir uns com os outros ou com o sistema host
+5. Reprodutibilidade: Ambientes isolados facilitam a reprodução de bugs e problemas, já que o ambiente de execução é consistente e controlável
+
+## Como o Runtime funciona?
+
+O sistema OpenHands Runtime usa uma arquitetura cliente-servidor implementada com contêineres Docker. Aqui está uma visão geral de como ele funciona:
+
+```mermaid
+graph TD
+    A[Imagem Docker Personalizada Fornecida pelo Usuário] --> B[Backend do OpenHands]
+    B -->|Constrói| C[Imagem do OH Runtime]
+    C -->|Inicia| D[Executor de Ação]
+    D -->|Inicializa| E[Navegador]
+    D -->|Inicializa| F[Shell Bash]
+    D -->|Inicializa| G[Plugins]
+    G -->|Inicializa| L[Servidor Jupyter]
+
+    B -->|Gera| H[Agente]
+    B -->|Gera| I[EventStream]
+    I <--->|Executa Ação para
+    Obter Observação
+    via API REST
+    | D
+
+    H -->|Gera Ação| I
+    I -->|Obtém Observação| H
+
+    subgraph "Contêiner Docker"
+    D
+    E
+    F
+    G
+    L
+    end
+```
+
+1. Entrada do Usuário: O usuário fornece uma imagem Docker base personalizada
+2. Construção da Imagem: O OpenHands constrói uma nova imagem Docker (a "imagem do OH runtime") com base na imagem fornecida pelo usuário. Essa nova imagem inclui código específico do OpenHands, principalmente o "cliente de runtime"
+3. Inicialização do Contêiner: Quando o OpenHands inicia, ele lança um contêiner Docker usando a imagem do OH runtime
+4. Inicialização do Servidor de Execução de Ação: O servidor de execução de ação inicializa um `ActionExecutor` dentro do contêiner, configurando os componentes necessários, como um shell bash e carregando quaisquer plugins especificados
+5. Comunicação: O backend do OpenHands (`openhands/runtime/impl/eventstream/eventstream_runtime.py`) se comunica com o servidor de execução de ação por meio de uma API RESTful, enviando ações e recebendo observações
+6. Execução da Ação: O cliente de runtime recebe ações do backend, as executa no ambiente isolado e envia de volta as observações
+7. Retorno da Observação: O servidor de execução de ação envia os resultados da execução de volta para o backend do OpenHands como observações
+
+O papel do cliente:
+
+- Ele atua como um intermediário entre o backend do OpenHands e o ambiente isolado
+- Ele executa vários tipos de ações (comandos shell, operações de arquivo, código Python, etc.) com segurança dentro do contêiner
+- Ele gerencia o estado do ambiente isolado, incluindo o diretório de trabalho atual e os plugins carregados
+- Ele formata e retorna observações para o backend, garantindo uma interface consistente para processar os resultados
+
+## Como o OpenHands constrói e mantém imagens do OH Runtime
+
+A abordagem do OpenHands para construir e gerenciar imagens de runtime garante eficiência, consistência e flexibilidade na criação e manutenção de imagens Docker para ambientes de produção e desenvolvimento.
+
+Confira o [código relevante](https://github.com/All-Hands-AI/OpenHands/blob/main/openhands/runtime/utils/runtime_build.py) se você estiver interessado em mais detalhes.
+
+### Sistema de Tags de Imagem
+
+O OpenHands usa um sistema de três tags para suas imagens de runtime para equilibrar reprodutibilidade com flexibilidade.
+As tags podem estar em um dos 2 formatos:
+
+- **Tag Versionada**: `oh_v{openhands_version}_{base_image}` (ex.: `oh_v0.9.9_nikolaik_s_python-nodejs_t_python3.12-nodejs22`)
+- **Tag de Bloqueio**: `oh_v{openhands_version}_{16_digit_lock_hash}` (ex.: `oh_v0.9.9_1234567890abcdef`)
+- **Tag de Origem**: `oh_v{openhands_version}_{16_digit_lock_hash}_{16_digit_source_hash}`
+  (ex.: `oh_v0.9.9_1234567890abcdef_1234567890abcdef`)
+
+#### Tag de Origem - Mais Específica
+
+Estes são os primeiros 16 dígitos do MD5 do hash do diretório para o diretório de origem. Isso fornece um hash
+apenas para o código-fonte do openhands
+
+#### Tag de Bloqueio
+
+Este hash é construído a partir dos primeiros 16 dígitos do MD5 de:
+
+- O nome da imagem base sobre a qual a imagem foi construída (ex.: `nikolaik/python-nodejs:python3.12-nodejs22`)
+- O conteúdo do `pyproject.toml` incluído na imagem.
+- O conteúdo do `poetry.lock` incluído na imagem.
+
+Isso efetivamente fornece um hash para as dependências do Openhands independente do código-fonte.
+
+#### Tag Versionada - Mais Genérica
+
+Esta tag é uma concatenação da versão do openhands e do nome da imagem base (transformado para se adequar ao padrão de tag).
+
+#### Processo de Construção
+
+Ao gerar uma imagem...
+
+- **Sem reconstrução**: O OpenHands primeiro verifica se existe uma imagem com a mesma **tag de origem mais específica**. Se houver tal imagem,
+  nenhuma construção é realizada - a imagem existente é usada.
+- **Reconstrução mais rápida**: O OpenHands verifica em seguida se existe uma imagem com a **tag de bloqueio genérica**. Se houver tal imagem,
+  o OpenHands constrói uma nova imagem com base nela, ignorando todas as etapas de instalação (como `poetry install` e
+  `apt-get`), exceto uma operação final para copiar o código-fonte atual. A nova imagem é marcada apenas com uma
+  tag de **origem**.
+- **Reconstrução razoável**: Se não existir uma tag de **origem** nem de **bloqueio**, uma imagem será construída com base na imagem com tag **versionada**.
+  Na imagem com tag versionada, a maioria das dependências já deve estar instalada, economizando tempo.
+- **Reconstrução mais lenta**: Se todas as três tags não existirem, uma nova imagem é construída com base na imagem
+  base (o que é uma operação mais lenta). Esta nova imagem é marcada com todas as tags de **origem**, **bloqueio** e **versionada**.
+
+Essa abordagem de tags permite que o OpenHands gerencie com eficiência ambientes de desenvolvimento e produção.
+
+1. Código-fonte e Dockerfile idênticos sempre produzem a mesma imagem (via tags baseadas em hash)
+2. O sistema pode reconstruir rapidamente imagens quando ocorrem pequenas alterações (aproveitando imagens compatíveis recentes)
+3. A tag de **bloqueio** (ex.: `runtime:oh_v0.9.3_1234567890abcdef`) sempre aponta para a construção mais recente para uma combinação específica de imagem base, dependência e versão do OpenHands
+
+## Sistema de Plugins do Runtime
+
+O OpenHands Runtime suporta um sistema de plugins que permite estender a funcionalidade e personalizar o ambiente de runtime. Os plugins são inicializados quando o cliente de runtime é iniciado.
+
+Confira [um exemplo do plugin Jupyter aqui](https://github.com/All-Hands-AI/OpenHands/blob/ecf4aed28b0cf7c18d4d8ff554883ba182fc6bdd/openhands/runtime/plugins/jupyter/__init__.py#L21-L55) se você quiser implementar seu próprio plugin.
+
+_Mais detalhes sobre o sistema de Plugins ainda estão em construção - contribuições são bem-vindas!_
+
+Aspectos-chave do sistema de plugins:
+
+1. Definição de Plugin: Os plugins são definidos como classes Python que herdam de uma classe base `Plugin`
+2. Registro de Plugin: Os plugins disponíveis são registrados em um dicionário `ALL_PLUGINS`
+3. Especificação de Plugin: Os plugins são associados a `Agent.sandbox_plugins: list[PluginRequirement]`. Os usuários podem especificar quais plugins carregar ao inicializar o runtime
+4. Inicialização: Os plugins são inicializados de forma assíncrona quando o cliente de runtime é iniciado
+5. Uso: O cliente de runtime pode usar plugins inicializados para estender suas capacidades (por exemplo, o JupyterPlugin para executar células IPython)

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/cloud/cloud-github-resolver.md

@@ -0,0 +1,33 @@
+Here is the translation to Brazilian Portuguese:
+
+# GitHub Cloud Resolver
+
+O GitHub Cloud Resolver automatiza correções de código e fornece assistência inteligente para seus repositórios.
+
+## Configuração
+
+O Resolvedor do GitHub na Nuvem está disponível automaticamente quando você
+[concede acesso ao repositório do OpenHands Cloud](./openhands-cloud.md#adding-repository-access).
+
+## Uso
+
+Após conceder acesso ao repositório do OpenHands Cloud, você pode usar o Resolvedor do GitHub na Nuvem nos problemas e pull requests
+do repositório.
+
+### Issues
+
+No seu repositório, rotule um issue com `openhands`. O OpenHands irá:
+
+1. Comentar no issue para informar que está trabalhando nele.
+   - Você pode clicar no link para acompanhar o progresso no OpenHands Cloud.
+2. Abrir um pull request se determinar que o issue foi resolvido com sucesso.
+3. Comentar no issue com um resumo das tarefas realizadas e um link para o pull request.
+
+### Pull Requests
+
+Para fazer o OpenHands trabalhar em pull requests, use `@openhands` em comentários de nível superior ou inline para: - Fazer perguntas - Solicitar atualizações - Obter explicações de código
+
+O OpenHands irá:
+
+1. Comentar no PR para informar que está trabalhando nele.
+2. Realizar a tarefa.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/cloud/openhands-cloud.md

@@ -0,0 +1,45 @@
+# Openhands Cloud
+
+O OpenHands Cloud é a versão hospedada na nuvem do OpenHands da All Hands AI.
+
+## Acessando o OpenHands Cloud
+
+Atualmente, os usuários estão sendo admitidos para acessar o OpenHands Cloud em ondas. Para se inscrever,
+[entre na lista de espera](https://www.all-hands.dev/join-waitlist). Assim que for aprovado, você receberá um e-mail com
+instruções sobre como acessá-lo.
+
+## Primeiros Passos
+
+Após visitar o OpenHands Cloud, você será solicitado a se conectar com sua conta do GitHub:
+1. Após ler e aceitar os termos de serviço, clique em `Connect to GitHub`.
+2. Revise as permissões solicitadas pelo OpenHands e clique em `Authorize OpenHands AI`.
+   - O OpenHands exigirá algumas permissões da sua conta do GitHub. Para ler mais sobre essas permissões,
+     você pode clicar no link `Learn more` na página de autorização do GitHub.
+
+## Acesso ao Repositório
+
+### Adicionando Acesso ao Repositório
+
+Você pode conceder ao OpenHands acesso específico ao repositório:
+1. Clique no menu suspenso `Select a GitHub project`, selecione `Add more repositories...`.
+2. Selecione a organização e escolha os repositórios específicos para conceder acesso ao OpenHands.
+   - O Openhands solicita tokens de curta duração (expiração de 8 horas) com estas permissões:
+     - Actions: Read and write
+     - Administration: Read-only
+     - Commit statuses: Read and write
+     - Contents: Read and write
+     - Issues: Read and write
+     - Metadata: Read-only
+     - Pull requests: Read and write
+     - Webhooks: Read and write
+     - Workflows: Read and write
+   - O acesso ao repositório para um usuário é concedido com base em:
+     - Permissão concedida para o repositório.
+     - Permissões do GitHub do usuário (proprietário/colaborador).
+3. Clique em `Install & Authorize`.
+
+### Modificando o Acesso ao Repositório
+
+Você pode modificar o acesso ao repositório a qualquer momento:
+* Usando o mesmo fluxo de trabalho `Select a GitHub project > Add more repositories`, ou
+* Visitando a página de Configurações e selecionando `Configure GitHub Repositories` na seção `GitHub Settings`.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/configuration-options.md

@@ -0,0 +1,396 @@
+# Opções de Configuração
+
+Este guia detalha todas as opções de configuração disponíveis para o OpenHands, ajudando você a personalizar seu comportamento e integrá-lo com outros serviços.
+
+:::note
+Se você estiver executando no [Modo GUI](https://docs.all-hands.dev/modules/usage/how-to/gui-mode), as configurações disponíveis na UI de Configurações sempre terão precedência.
+:::
+
+## Configuração Principal
+
+As opções de configuração principais são definidas na seção `[core]` do arquivo `config.toml`.
+
+### Chaves de API
+- `e2b_api_key`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Chave de API para E2B
+
+- `modal_api_token_id`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: ID do token de API para Modal
+
+- `modal_api_token_secret`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Segredo do token de API para Modal
+
+### Workspace
+- `workspace_base`
+  - Tipo: `str`
+  - Padrão: `"./workspace"`
+  - Descrição: Caminho base para o workspace
+
+- `cache_dir`
+  - Tipo: `str`
+  - Padrão: `"/tmp/cache"`
+  - Descrição: Caminho do diretório de cache
+
+### Depuração e Log
+- `debug`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Habilitar depuração
+
+- `disable_color`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Desabilitar cor na saída do terminal
+
+### Trajetórias
+- `save_trajectory_path`
+  - Tipo: `str`
+  - Padrão: `"./trajectories"`
+  - Descrição: Caminho para armazenar trajetórias (pode ser uma pasta ou um arquivo). Se for uma pasta, as trajetórias serão salvas em um arquivo nomeado com o nome do id da sessão e extensão .json, nessa pasta.
+
+- `replay_trajectory_path`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Caminho para carregar uma trajetória e reproduzir. Se fornecido, deve ser um caminho para o arquivo de trajetória no formato JSON. As ações no arquivo de trajetória seriam reproduzidas primeiro antes de qualquer instrução do usuário ser executada.
+
+### Armazenamento de Arquivos
+- `file_store_path`
+  - Tipo: `str`
+  - Padrão: `"/tmp/file_store"`
+  - Descrição: Caminho do armazenamento de arquivos
+
+- `file_store`
+  - Tipo: `str`
+  - Padrão: `"memory"`
+  - Descrição: Tipo de armazenamento de arquivos
+
+- `file_uploads_allowed_extensions`
+  - Tipo: `list of str`
+  - Padrão: `[".*"]`
+  - Descrição: Lista de extensões de arquivo permitidas para uploads
+
+- `file_uploads_max_file_size_mb`
+  - Tipo: `int`
+  - Padrão: `0`
+  - Descrição: Tamanho máximo de arquivo para uploads, em megabytes
+
+- `file_uploads_restrict_file_types`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Restringir tipos de arquivo para uploads de arquivos
+
+- `file_uploads_allowed_extensions`
+  - Tipo: `list of str`
+  - Padrão: `[".*"]`
+  - Descrição: Lista de extensões de arquivo permitidas para uploads
+
+### Gerenciamento de Tarefas
+- `max_budget_per_task`
+  - Tipo: `float`
+  - Padrão: `0.0`
+  - Descrição: Orçamento máximo por tarefa (0.0 significa sem limite)
+
+- `max_iterations`
+  - Tipo: `int`
+  - Padrão: `100`
+  - Descrição: Número máximo de iterações
+
+### Configuração do Sandbox
+- `workspace_mount_path_in_sandbox`
+  - Tipo: `str`
+  - Padrão: `"/workspace"`
+  - Descrição: Caminho para montar o workspace no sandbox
+
+- `workspace_mount_path`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Caminho para montar o workspace
+
+- `workspace_mount_rewrite`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Caminho para reescrever o caminho de montagem do workspace. Você geralmente pode ignorar isso, refere-se a casos especiais de execução dentro de outro contêiner.
+
+### Diversos
+- `run_as_openhands`
+  - Tipo: `bool`
+  - Padrão: `true`
+  - Descrição: Executar como OpenHands
+
+- `runtime`
+  - Tipo: `str`
+  - Padrão: `"docker"`
+  - Descrição: Ambiente de execução
+
+- `default_agent`
+  - Tipo: `str`
+  - Padrão: `"CodeActAgent"`
+  - Descrição: Nome do agente padrão
+
+- `jwt_secret`
+  - Tipo: `str`
+  - Padrão: `uuid.uuid4().hex`
+  - Descrição: Segredo JWT para autenticação. Por favor, defina seu próprio valor.
+
+## Configuração do LLM
+
+As opções de configuração do LLM (Large Language Model) são definidas na seção `[llm]` do arquivo `config.toml`.
+
+Para usá-las com o comando docker, passe `-e LLM_<opção>`. Exemplo: `-e LLM_NUM_RETRIES`.
+
+:::note
+Para configurações de desenvolvimento, você também pode definir configurações de LLM personalizadas nomeadas. Veja [Configurações Personalizadas de LLM](./llms/custom-llm-configs) para detalhes.
+:::
+
+**Credenciais AWS**
+- `aws_access_key_id`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: ID da chave de acesso AWS
+
+- `aws_region_name`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Nome da região AWS
+
+- `aws_secret_access_key`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Chave secreta de acesso AWS
+
+### Configuração da API
+- `api_key`
+  - Tipo: `str`
+  - Padrão: `None`
+  - Descrição: Chave de API a ser usada
+
+- `base_url`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: URL base da API
+
+- `api_version`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Versão da API
+
+- `input_cost_per_token`
+  - Tipo: `float`
+  - Padrão: `0.0`
+  - Descrição: Custo por token de entrada
+
+- `output_cost_per_token`
+  - Tipo: `float`
+  - Padrão: `0.0`
+  - Descrição: Custo por token de saída
+
+### Provedor LLM Personalizado
+- `custom_llm_provider`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Provedor LLM personalizado
+
+
+### Tratamento de Mensagens
+- `max_message_chars`
+  - Tipo: `int`
+  - Padrão: `30000`
+  - Descrição: O número máximo aproximado de caracteres no conteúdo de um evento incluído no prompt para o LLM. Observações maiores são truncadas.
+
+- `max_input_tokens`
+  - Tipo: `int`
+  - Padrão: `0`
+  - Descrição: Número máximo de tokens de entrada
+
+- `max_output_tokens`
+  - Tipo: `int`
+  - Padrão: `0`
+  - Descrição: Número máximo de tokens de saída
+
+### Seleção de Modelo
+- `model`
+  - Tipo: `str`
+  - Padrão: `"claude-3-5-sonnet-20241022"`
+  - Descrição: Modelo a ser usado
+
+### Tentativas
+- `num_retries`
+  - Tipo: `int`
+  - Padrão: `8`
+  - Descrição: Número de tentativas a serem feitas
+
+- `retry_max_wait`
+  - Tipo: `int`
+  - Padrão: `120`
+  - Descrição: Tempo máximo de espera (em segundos) entre tentativas
+
+- `retry_min_wait`
+  - Tipo: `int`
+  - Padrão: `15`
+  - Descrição: Tempo mínimo de espera (em segundos) entre tentativas
+
+- `retry_multiplier`
+  - Tipo: `float`
+  - Padrão: `2.0`
+  - Descrição: Multiplicador para cálculo de backoff exponencial
+
+### Opções Avançadas
+- `drop_params`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Descartar quaisquer parâmetros não mapeados (não suportados) sem causar uma exceção
+
+- `caching_prompt`
+  - Tipo: `bool`
+  - Padrão: `true`
+  - Descrição: Usar o recurso de cache de prompt se fornecido pelo LLM e suportado
+
+- `ollama_base_url`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: URL base para a API OLLAMA
+
+- `temperature`
+  - Tipo: `float`
+  - Padrão: `0.0`
+  - Descrição: Temperatura para a API
+
+- `timeout`
+  - Tipo: `int`
+  - Padrão: `0`
+  - Descrição: Timeout para a API
+
+- `top_p`
+  - Tipo: `float`
+  - Padrão: `1.0`
+  - Descrição: Top p para a API
+
+- `disable_vision`
+  - Tipo: `bool`
+  - Padrão: `None`
+  - Descrição: Se o modelo é capaz de visão, esta opção permite desabilitar o processamento de imagem (útil para redução de custo)
+
+## Configuração do Agente
+
+As opções de configuração do agente são definidas nas seções `[agent]` e `[agent.<agent_name>]` do arquivo `config.toml`.
+
+### Configuração do LLM
+- `llm_config`
+  - Tipo: `str`
+  - Padrão: `'your-llm-config-group'`
+  - Descrição: O nome da configuração LLM a ser usada
+
+### Configuração do Espaço de Ação
+- `function_calling`
+  - Tipo: `bool`
+  - Padrão: `true`
+  - Descrição: Se a chamada de função está habilitada
+
+- `codeact_enable_browsing`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Se o delegado de navegação está habilitado no espaço de ação (funciona apenas com chamada de função)
+
+- `codeact_enable_llm_editor`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Se o editor LLM está habilitado no espaço de ação (funciona apenas com chamada de função)
+
+- `codeact_enable_jupyter`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Se o Jupyter está habilitado no espaço de ação
+
+- `enable_history_truncation`
+  - Tipo: `bool`
+  - Padrão: `true`
+  - Descrição: Se o histórico deve ser truncado para continuar a sessão ao atingir o limite de comprimento de contexto do LLM
+
+### Uso de Microagentes
+- `enable_prompt_extensions`
+  - Tipo: `bool`
+  - Padrão: `true`
+  - Descrição: Se deve usar microagentes
+
+- `disabled_microagents`
+  - Tipo: `list of str`
+  - Padrão: `None`
+  - Descrição: Uma lista de microagentes a serem desabilitados
+
+## Configuração do Sandbox
+
+As opções de configuração do sandbox são definidas na seção `[sandbox]` do arquivo `config.toml`.
+
+Para usá-las com o comando docker, passe `-e SANDBOX_<opção>`. Exemplo: `-e SANDBOX_TIMEOUT`.
+
+### Execução
+- `timeout`
+  - Tipo: `int`
+  - Padrão: `120`
+  - Descrição: Timeout do sandbox em segundos
+
+- `user_id`
+  - Tipo: `int`
+  - Padrão: `1000`
+  - Descrição: ID do usuário do sandbox
+
+### Imagem do Contêiner
+- `base_container_image`
+  - Tipo: `str`
+  - Padrão: `"nikolaik/python-nodejs:python3.12-nodejs22"`
+  - Descrição: Imagem do contêiner a ser usada para o sandbox
+
+### Rede
+- `use_host_network`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Usar a rede do host
+
+- `runtime_binding_address`
+  - Tipo: `str`
+  - Padrão: `0.0.0.0`
+  - Descrição: O endereço de ligação para as portas de tempo de execução. Especifica em qual interface de rede na máquina host o Docker deve ligar as portas de tempo de execução.
+
+### Linting e Plugins
+- `enable_auto_lint`
+  - Tipo: `bool`
+  - Padrão: `false`
+  - Descrição: Habilitar linting automático após a edição
+
+- `initialize_plugins`
+  - Tipo: `bool`
+  - Padrão: `true`
+  - Descrição: Se deve inicializar plugins
+
+### Dependências e Ambiente
+- `runtime_extra_deps`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Dependências extras a serem instaladas na imagem de tempo de execução
+
+- `runtime_startup_env_vars`
+  - Tipo: `dict`
+  - Padrão: `{}`
+  - Descrição: Variáveis de ambiente a serem definidas no lançamento do tempo de execução
+
+### Avaliação
+- `browsergym_eval_env`
+  - Tipo: `str`
+  - Padrão: `""`
+  - Descrição: Ambiente BrowserGym a ser usado para avaliação
+
+## Configuração de Segurança
+
+As opções de configuração de segurança são definidas na seção `[security]` do arquivo `config.toml`.
+
+Para usá-las com o comando docker, passe `-e SECURITY_<opção>`. Exemplo: `-e SECURITY_CONFIRMATION_MODE`.
+
+### Modo de Confirmação
+- `confirmation_mode`
+  - Tipo

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/feedback.md

@@ -0,0 +1,38 @@
+# ✅ Fornecendo Feedback
+
+Ao usar o OpenHands, você encontrará casos em que as coisas funcionam bem e outros em que não funcionam. Nós encorajamos você a fornecer feedback quando usar o OpenHands para ajudar a dar feedback para a equipe de desenvolvimento e, talvez mais importante, criar um corpus aberto de exemplos de treinamento de agentes de codificação -- Share-OpenHands!
+
+## 📝 Como Fornecer Feedback
+
+Fornecer feedback é fácil! Quando você estiver usando o OpenHands, você pode pressionar o botão de polegar para cima ou polegar para baixo a qualquer momento durante sua interação. Você será solicitado a fornecer seu endereço de e-mail (por exemplo, para que possamos entrar em contato com você se quisermos fazer alguma pergunta de acompanhamento), e você pode escolher se deseja fornecer feedback publicamente ou privadamente.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/5rFx-StMVV0?si=svo7xzp6LhGK_GXr" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+## 📜 Uso de Dados e Privacidade
+
+### Configurações de compartilhamento de dados
+
+Quando você envia dados, você pode enviá-los publicamente ou privadamente.
+
+- Dados **públicos** serão distribuídos sob a Licença MIT, como o próprio OpenHands, e podem ser usados pela comunidade para treinar e testar modelos. Obviamente, o feedback que você pode tornar público será mais valioso para a comunidade como um todo, então quando você não estiver lidando com informações confidenciais, nós encorajamos você a escolher esta opção!
+- Dados **privados** serão disponibilizados para a equipe do OpenHands com o propósito de melhorar o OpenHands. No entanto, um link com um ID único ainda será criado para que você possa compartilhar publicamente com outras pessoas.
+
+### Quem coleta e armazena os dados?
+
+Os dados são coletados e armazenados pela [All Hands AI](https://all-hands.dev), uma empresa fundada pelos mantenedores do OpenHands para apoiar e melhorar o OpenHands.
+
+### Como os dados públicos serão divulgados?
+
+Os dados públicos serão divulgados quando atingirmos marcos fixos, como 1.000 exemplos públicos, 10.000 exemplos públicos, etc. Neste momento, seguiremos o seguinte processo de divulgação:
+
+1. Todas as pessoas que contribuíram com feedback público receberão um e-mail descrevendo a divulgação dos dados e terão a oportunidade de optar por não participar.
+2. A pessoa ou pessoas responsáveis pela divulgação dos dados realizarão o controle de qualidade dos dados, removendo feedback de baixa qualidade, removendo endereços de e-mail dos remetentes e tentando remover quaisquer informações confidenciais.
+3. Os dados serão divulgados publicamente sob a licença MIT por meio de sites comumente usados, como GitHub ou Hugging Face.
+
+### E se eu quiser que meus dados sejam excluídos?
+
+Para dados nos servidores da All Hands AI, teremos prazer em excluí-los mediante solicitação:
+
+**Uma Parte dos Dados:** Se você deseja que uma parte dos dados seja excluída, em breve adicionaremos um mecanismo para excluir partes dos dados usando o link e a senha exibidos na interface quando você envia os dados.
+
+**Todos os Dados:** Se você deseja que todas as partes de seus dados sejam excluídas, ou se você não possui o ID e a senha que recebeu ao enviar os dados, entre em contato com `contact@all-hands.dev` a partir do endereço de e-mail que você registrou quando enviou os dados originalmente.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/getting-started.mdx

@@ -0,0 +1,111 @@
+# Começando com o OpenHands
+
+Então você [executou o OpenHands](./installation) e
+[configurou seu LLM](./installation#setup). E agora?
+
+O OpenHands pode ajudá-lo a lidar com uma ampla variedade de tarefas de engenharia. Mas a tecnologia
+ainda é nova, e estamos longe de ter agentes que possam assumir tarefas de engenharia grandes e complicadas
+sem qualquer orientação. Portanto, é importante ter uma noção do que o agente
+faz bem e onde ele pode precisar de alguma ajuda.
+
+## Olá Mundo
+
+A primeira coisa que você pode querer tentar é um exemplo simples de "olá mundo".
+Isso pode ser mais complicado do que parece!
+
+Tente solicitar ao agente:
+> Por favor, escreva um script bash hello.sh que imprima "hello world!"
+
+Você deve ver que o agente não apenas escreve o script, mas também define as permissões
+corretas e executa o script para verificar a saída.
+
+Você pode continuar solicitando ao agente para refinar seu código. Esta é uma ótima maneira de
+trabalhar com agentes. Comece de forma simples e itere.
+
+> Por favor, modifique hello.sh para que ele aceite um nome como o primeiro argumento, mas use "world" como padrão
+
+Você também pode trabalhar em qualquer linguagem que precisar, embora o agente possa precisar de algum
+tempo para configurar seu ambiente!
+
+> Por favor, converta hello.sh para um script Ruby e execute-o
+
+## Construindo do Zero
+
+Os agentes se saem excepcionalmente bem em tarefas "greenfield" (tarefas em que eles não precisam
+de nenhum contexto sobre uma base de código existente) e podem simplesmente começar do zero.
+
+É melhor começar com uma tarefa simples e, em seguida, iterar sobre ela. Também é melhor ser
+o mais específico possível sobre o que você deseja, qual deve ser a pilha de tecnologia, etc.
+
+Por exemplo, podemos construir um aplicativo de lista de tarefas:
+
+> Por favor, construa um aplicativo básico de lista de tarefas em React. Ele deve ser apenas frontend e todo o estado
+> deve ser mantido no localStorage.
+
+Podemos continuar iterando no aplicativo assim que o esqueleto estiver lá:
+
+> Por favor, permita adicionar uma data de vencimento opcional para cada tarefa.
+
+Assim como no desenvolvimento normal, é bom fazer commit e push do seu código com frequência.
+Dessa forma, você sempre pode reverter para um estado antigo se o agente sair do caminho.
+Você pode pedir ao agente para fazer commit e push para você:
+
+> Por favor, faça commit das alterações e envie-as para uma nova branch chamada "feature/due-dates"
+
+
+## Adicionando Novo Código
+
+O OpenHands também pode fazer um ótimo trabalho adicionando novo código a uma base de código existente.
+
+Por exemplo, você pode pedir ao OpenHands para adicionar uma nova ação do GitHub ao seu projeto
+que faça lint do seu código. O OpenHands pode dar uma olhada na sua base de código para ver qual linguagem
+ele deve usar e, em seguida, soltar um novo arquivo em `./github/workflows/lint.yml`.
+
+> Por favor, adicione uma ação do GitHub que faça lint do código neste repositório.
+
+Algumas tarefas podem exigir um pouco mais de contexto. Embora o OpenHands possa usar `ls` e `grep`
+para pesquisar em sua base de código, fornecer contexto antecipadamente permite que ele se mova mais rápido
+e com mais precisão. E isso custará menos tokens para você!
+
+> Por favor, modifique ./backend/api/routes.js para adicionar uma nova rota que retorne uma lista de todas as tarefas.
+
+> Por favor, adicione um novo componente React que exiba uma lista de Widgets no diretório ./frontend/components.
+> Ele deve usar o componente Widget existente.
+
+## Refatoração
+
+O OpenHands é ótimo em refatorar código existente, especialmente em pequenos pedaços.
+Você provavelmente não vai querer tentar rearquitetar toda a sua base de código, mas dividir
+arquivos e funções longas, renomear variáveis, etc. tendem a funcionar muito bem.
+
+> Por favor, renomeie todas as variáveis de uma letra em ./app.go.
+
+> Por favor, divida a função `build_and_deploy_widgets` em duas funções, `build_widgets` e `deploy_widgets` em widget.php.
+
+> Por favor, divida ./api/routes.js em arquivos separados para cada rota.
+
+## Correções de Bugs
+
+O OpenHands também pode ajudá-lo a rastrear e corrigir bugs em seu código. Mas como qualquer
+desenvolvedor sabe, a correção de bugs pode ser extremamente complicada e, muitas vezes, o OpenHands precisará de mais contexto.
+Ajuda se você diagnosticou o bug, mas quer que o OpenHands descubra a lógica.
+
+> Atualmente, o campo de e-mail no endpoint `/subscribe` está rejeitando domínios .io. Por favor, corrija isso.
+
+> A função `search_widgets` em ./app.py está fazendo uma pesquisa sensível a maiúsculas e minúsculas. Por favor, torne-a insensível a maiúsculas e minúsculas.
+
+Muitas vezes, ajuda fazer o desenvolvimento orientado a testes ao corrigir bugs com um agente.
+Você pode pedir ao agente para escrever um novo teste e, em seguida, iterar até que ele corrija o bug:
+
+> A função `hello` trava na string vazia. Por favor, escreva um teste que reproduza esse bug e, em seguida, corrija o código para que ele passe.
+
+## Mais
+
+O OpenHands é capaz de ajudar em praticamente qualquer tarefa de codificação, mas é necessária alguma prática
+para tirar o máximo proveito dele. Lembre-se de:
+* Manter suas tarefas pequenas.
+* Ser o mais específico possível.
+* Fornecer o máximo de contexto possível.
+* Fazer commit e push com frequência.
+
+Veja [Melhores Práticas de Prompt](./prompting/prompting-best-practices) para mais dicas sobre como obter o máximo do OpenHands.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/cli-mode.md

@@ -0,0 +1,96 @@
+# Modo CLI
+
+O OpenHands pode ser executado em um modo CLI interativo, que permite aos usuários iniciar uma sessão interativa via linha de comando.
+
+Esse modo é diferente do [modo headless](headless-mode), que é não interativo e melhor para scripting.
+
+## Com Python
+
+Para iniciar uma sessão interativa do OpenHands via linha de comando:
+
+1. Certifique-se de ter seguido as [instruções de configuração de desenvolvimento](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
+2. Execute o seguinte comando:
+
+```bash
+poetry run python -m openhands.core.cli
+```
+
+Esse comando iniciará uma sessão interativa onde você pode inserir tarefas e receber respostas do OpenHands.
+
+Você precisará definir seu modelo, chave de API e outras configurações via variáveis de ambiente
+[ou o arquivo `config.toml`](https://github.com/All-Hands-AI/OpenHands/blob/main/config.template.toml).
+
+## Com Docker
+
+Para executar o OpenHands no modo CLI com Docker:
+
+1. Defina as seguintes variáveis de ambiente no seu terminal:
+
+- `WORKSPACE_BASE` para o diretório que você deseja que o OpenHands edite (Ex: `export WORKSPACE_BASE=$(pwd)/workspace`).
+- `LLM_MODEL` para o modelo a ser usado (Ex: `export LLM_MODEL="anthropic/claude-3-5-sonnet-20241022"`).
+- `LLM_API_KEY` para a chave de API (Ex: `export LLM_API_KEY="sk_test_12345"`).
+
+2. Execute o seguinte comando Docker:
+
+```bash
+docker run -it \
+    --pull=always \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
+    -e SANDBOX_USER_ID=$(id -u) \
+    -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
+    -e LLM_API_KEY=$LLM_API_KEY \
+    -e LLM_MODEL=$LLM_MODEL \
+    -v $WORKSPACE_BASE:/opt/workspace_base \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    -v ~/.openhands-state:/.openhands-state \
+    --add-host host.docker.internal:host-gateway \
+    --name openhands-app-$(date +%Y%m%d%H%M%S) \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29 \
+    python -m openhands.core.cli
+```
+
+Esse comando iniciará uma sessão interativa no Docker onde você pode inserir tarefas e receber respostas do OpenHands.
+
+## Exemplos de Comandos CLI e Saídas Esperadas
+
+Aqui estão alguns exemplos de comandos CLI e suas saídas esperadas:
+
+### Exemplo 1: Tarefa Simples
+
+```bash
+>> Escreva um script Python que imprima "Hello, World!"
+```
+
+Saída Esperada:
+
+```bash
+🤖 Claro! Aqui está um script Python que imprime "Hello, World!":
+
+❯ print("Hello, World!")
+```
+
+### Exemplo 2: Comando Bash
+
+```bash
+>> Crie um diretório chamado "test_dir"
+```
+
+Saída Esperada:
+
+```bash
+🤖 Criando um diretório chamado "test_dir":
+
+❯ mkdir test_dir
+```
+
+### Exemplo 3: Tratamento de Erro
+
+```bash
+>> Exclua um arquivo inexistente
+```
+
+Saída Esperada:
+
+```bash
+🤖 Ocorreu um erro. Por favor, tente novamente.
+```

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/custom-sandbox-guide.md

@@ -0,0 +1,97 @@
+# Sandbox Personalizado
+
+O sandbox é onde o agente realiza suas tarefas. Em vez de executar comandos diretamente no seu computador
+(o que poderia ser arriscado), o agente os executa dentro de um contêiner Docker.
+
+O sandbox padrão do OpenHands (`python-nodejs:python3.12-nodejs22`
+do [nikolaik/python-nodejs](https://hub.docker.com/r/nikolaik/python-nodejs)) vem com alguns pacotes instalados, como
+python e Node.js, mas pode precisar de outros softwares instalados por padrão.
+
+Você tem duas opções para personalização:
+
+- Usar uma imagem existente com o software necessário.
+- Criar sua própria imagem personalizada do Docker.
+
+Se você escolher a primeira opção, pode pular a seção `Crie Sua Imagem Docker`.
+
+## Crie Sua Imagem Docker
+
+Para criar uma imagem personalizada do Docker, ela deve ser baseada no Debian.
+
+Por exemplo, se você quiser que o OpenHands tenha o `ruby` instalado, você pode criar um `Dockerfile` com o seguinte conteúdo:
+
+```dockerfile
+FROM nikolaik/python-nodejs:python3.12-nodejs22
+
+# Instalar pacotes necessários
+RUN apt-get update && apt-get install -y ruby
+```
+
+Ou você pode usar uma imagem base específica do Ruby:
+
+```dockerfile
+FROM ruby:latest
+```
+
+Salve este arquivo em uma pasta. Em seguida, construa sua imagem Docker (por exemplo, chamada custom-image) navegando até a pasta no
+terminal e executando:
+```bash
+docker build -t custom-image .
+```
+
+Isso produzirá uma nova imagem chamada `custom-image`, que estará disponível no Docker.
+
+## Usando o Comando Docker
+
+Ao executar o OpenHands usando [o comando docker](/modules/usage/installation#start-the-app), substitua
+`-e SANDBOX_RUNTIME_CONTAINER_IMAGE=...` por `-e SANDBOX_BASE_CONTAINER_IMAGE=<nome da imagem personalizada>`:
+
+```commandline
+docker run -it --rm --pull=always \
+    -e SANDBOX_BASE_CONTAINER_IMAGE=custom-image \
+    ...
+```
+
+## Usando o Fluxo de Trabalho de Desenvolvimento
+
+### Configuração
+
+Primeiro, certifique-se de que você pode executar o OpenHands seguindo as instruções em [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
+
+### Especifique a Imagem Base do Sandbox
+
+No arquivo `config.toml` dentro do diretório OpenHands, defina `base_container_image` como a imagem que você deseja usar.
+Isso pode ser uma imagem que você já baixou ou uma que você construiu:
+
+```bash
+[core]
+...
+[sandbox]
+base_container_image="custom-image"
+```
+
+### Opções de Configuração Adicionais
+
+O arquivo `config.toml` suporta várias outras opções para personalizar seu sandbox:
+
+```toml
+[core]
+# Instalar dependências adicionais quando o runtime for construído
+# Pode conter quaisquer comandos shell válidos
+# Se você precisar do caminho para o interpretador Python em qualquer um desses comandos, pode usar a variável $OH_INTERPRETER_PATH
+runtime_extra_deps = """
+pip install numpy pandas
+apt-get update && apt-get install -y ffmpeg
+"""
+
+# Definir variáveis de ambiente para o runtime
+# Útil para configuração que precisa estar disponível em tempo de execução
+runtime_startup_env_vars = { DATABASE_URL = "postgresql://user:pass@localhost/db" }
+
+# Especificar a plataforma para builds de várias arquiteturas (por exemplo, "linux/amd64" ou "linux/arm64")
+platform = "linux/amd64"
+```
+
+### Executar
+
+Execute o OpenHands executando ```make run``` no diretório de nível superior.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/debugging.md

@@ -0,0 +1,71 @@
+# Debugging
+
+The following is intended as a primer on debugging OpenHands for Development purposes.
+
+## Server / VSCode
+
+The following `launch.json` will allow debugging the agent, controller and server elements, but not the sandbox (Which runs inside docker). It will ignore any changes inside the `workspace/` directory:
+
+```
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "OpenHands CLI",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "openhands.core.cli",
+            "justMyCode": false
+        },
+        {
+            "name": "OpenHands WebApp",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "uvicorn",
+            "args": [
+                "openhands.server.listen:app",
+                "--reload",
+                "--reload-exclude",
+                "${workspaceFolder}/workspace",
+                "--port",
+                "3000"
+            ],
+            "justMyCode": false
+        }
+    ]
+}
+```
+
+More specific debugging configurations which include more parameters may be specified:
+
+```
+    ...
+    {
+      "name": "Debug CodeAct",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "openhands.core.main",
+      "args": [
+        "-t",
+        "Ask me what your task is.",
+        "-d",
+        "${workspaceFolder}/workspace",
+        "-c",
+        "CodeActAgent",
+        "-l",
+        "llm.o1",
+        "-n",
+        "prompts"
+      ],
+      "justMyCode": false
+    }
+    ...
+```
+
+Values in the snippet above can be updated such that:
+
+    * *t*: the task
+    * *d*: the openhands workspace directory
+    * *c*: the agent
+    * *l*: the LLM config (pre-defined in config.toml)
+    * *n*: session name (e.g. eventstream name)

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/development-overview.md

@@ -0,0 +1,74 @@
+---
+sidebar_position: 9
+---
+
+# Visão Geral do Desenvolvimento
+
+Este guia fornece uma visão geral dos principais recursos de documentação disponíveis no repositório OpenHands. Se você está procurando contribuir, entender a arquitetura ou trabalhar em componentes específicos, esses recursos irão ajudá-lo a navegar pelo codebase de forma eficaz.
+
+## Documentação Principal
+
+### Fundamentos do Projeto
+- **Visão Geral do Projeto Principal** (`/README.md`)
+  O ponto de entrada principal para entender o OpenHands, incluindo recursos e instruções básicas de configuração.
+
+- **Guia de Desenvolvimento** (`/Development.md`)
+  Guia abrangente para desenvolvedores que trabalham no OpenHands, incluindo configuração, requisitos e fluxos de trabalho de desenvolvimento.
+
+- **Diretrizes de Contribuição** (`/CONTRIBUTING.md`)
+  Informações essenciais para contribuidores, abrangendo estilo de código, processo de PR e fluxos de trabalho de contribuição.
+
+### Documentação de Componentes
+
+#### Frontend
+- **Aplicação Frontend** (`/frontend/README.md`)
+  Guia completo para configurar e desenvolver a aplicação frontend baseada em React.
+
+#### Backend
+- **Implementação do Backend** (`/openhands/README.md`)
+  Documentação detalhada da implementação e arquitetura do backend em Python.
+
+- **Documentação do Servidor** (`/openhands/server/README.md`)
+  Detalhes de implementação do servidor, documentação da API e arquitetura de serviços.
+
+- **Ambiente de Execução** (`/openhands/runtime/README.md`)
+  Documentação abrangendo o ambiente de execução, modelo de execução e configurações de tempo de execução.
+
+#### Infraestrutura
+- **Documentação de Contêineres** (`/containers/README.md`)
+  Informações abrangentes sobre contêineres Docker, estratégias de implantação e gerenciamento de contêineres.
+
+### Testes e Avaliação
+- **Guia de Testes Unitários** (`/tests/unit/README.md`)
+  Instruções para escrever, executar e manter testes unitários.
+
+- **Framework de Avaliação** (`/evaluation/README.md`)
+  Documentação para o framework de avaliação, benchmarks e testes de desempenho.
+
+### Recursos Avançados
+- **Arquitetura de Microagentes** (`/microagents/README.md`)
+  Informações detalhadas sobre a arquitetura, implementação e uso de microagentes.
+
+### Padrões de Documentação
+- **Guia de Estilo de Documentação** (`/docs/DOC_STYLE_GUIDE.md`)
+  Padrões e diretrizes para escrever e manter a documentação do projeto.
+
+## Começando com o Desenvolvimento
+
+Se você é novo no desenvolvimento com OpenHands, recomendamos seguir esta sequência:
+
+1. Comece com o `README.md` principal para entender o propósito e os recursos do projeto
+2. Revise as diretrizes em `CONTRIBUTING.md` se você planeja contribuir
+3. Siga as instruções de configuração em `Development.md`
+4. Mergulhe na documentação de componentes específicos com base na sua área de interesse:
+   - Desenvolvedores frontend devem se concentrar em `/frontend/README.md`
+   - Desenvolvedores backend devem começar com `/openhands/README.md`
+   - O trabalho de infraestrutura deve começar com `/containers/README.md`
+
+## Atualizações da Documentação
+
+Ao fazer alterações no codebase, certifique-se de que:
+1. A documentação relevante seja atualizada para refletir suas alterações
+2. Novos recursos sejam documentados nos arquivos README apropriados
+3. Quaisquer alterações na API sejam refletidas na documentação do servidor
+4. A documentação siga o guia de estilo em `/docs/DOC_STYLE_GUIDE.md`

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/evaluation-harness.md

@@ -0,0 +1,278 @@
+# Avaliação
+
+Este guia fornece uma visão geral de como integrar seu próprio benchmark de avaliação ao framework OpenHands.
+
+## Configurar Ambiente e Configuração do LLM
+
+Por favor, siga as instruções [aqui](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md) para configurar seu ambiente de desenvolvimento local.
+O OpenHands no modo de desenvolvimento usa `config.toml` para manter o controle da maioria das configurações.
+
+Aqui está um exemplo de arquivo de configuração que você pode usar para definir e usar múltiplos LLMs:
+
+```toml
+[llm]
+# IMPORTANTE: adicione sua chave de API aqui e defina o modelo para o que você deseja avaliar
+model = "claude-3-5-sonnet-20241022"
+api_key = "sk-XXX"
+
+[llm.eval_gpt4_1106_preview_llm]
+model = "gpt-4-1106-preview"
+api_key = "XXX"
+temperature = 0.0
+
+[llm.eval_some_openai_compatible_model_llm]
+model = "openai/MODEL_NAME"
+base_url = "https://OPENAI_COMPATIBLE_URL/v1"
+api_key = "XXX"
+temperature = 0.0
+```
+
+
+## Como usar o OpenHands na linha de comando
+
+O OpenHands pode ser executado a partir da linha de comando usando o seguinte formato:
+
+```bash
+poetry run python ./openhands/core/main.py \
+        -i <max_iterations> \
+        -t "<task_description>" \
+        -c <agent_class> \
+        -l <llm_config>
+```
+
+Por exemplo:
+
+```bash
+poetry run python ./openhands/core/main.py \
+        -i 10 \
+        -t "Write me a bash script that prints hello world." \
+        -c CodeActAgent \
+        -l llm
+```
+
+Este comando executa o OpenHands com:
+- Um máximo de 10 iterações
+- A descrição da tarefa especificada
+- Usando o CodeActAgent
+- Com a configuração do LLM definida na seção `llm` do seu arquivo `config.toml`
+
+## Como o OpenHands funciona
+
+O ponto de entrada principal para o OpenHands está em `openhands/core/main.py`. Aqui está um fluxo simplificado de como ele funciona:
+
+1. Analisa os argumentos da linha de comando e carrega a configuração
+2. Cria um ambiente de execução usando `create_runtime()`
+3. Inicializa o agente especificado
+4. Executa o controlador usando `run_controller()`, que:
+   - Anexa o ambiente de execução ao agente
+   - Executa a tarefa do agente
+   - Retorna um estado final quando concluído
+
+A função `run_controller()` é o núcleo da execução do OpenHands. Ela gerencia a interação entre o agente, o ambiente de execução e a tarefa, lidando com coisas como simulação de entrada do usuário e processamento de eventos.
+
+
+## Maneira mais fácil de começar: Explorando Benchmarks Existentes
+
+Encorajamos você a revisar os vários benchmarks de avaliação disponíveis no [diretório `evaluation/benchmarks/`](https://github.com/All-Hands-AI/OpenHands/blob/main/evaluation/benchmarks) do nosso repositório.
+
+Para integrar seu próprio benchmark, sugerimos começar com aquele que mais se assemelha às suas necessidades. Essa abordagem pode simplificar significativamente seu processo de integração, permitindo que você construa sobre estruturas existentes e as adapte aos seus requisitos específicos.
+
+## Como criar um fluxo de trabalho de avaliação
+
+
+Para criar um fluxo de trabalho de avaliação para o seu benchmark, siga estas etapas:
+
+1. Importe as utilidades relevantes do OpenHands:
+   ```python
+    import openhands.agenthub
+    from evaluation.utils.shared import (
+        EvalMetadata,
+        EvalOutput,
+        make_metadata,
+        prepare_dataset,
+        reset_logger_for_multiprocessing,
+        run_evaluation,
+    )
+    from openhands.controller.state.state import State
+    from openhands.core.config import (
+        AppConfig,
+        SandboxConfig,
+        get_llm_config_arg,
+        parse_arguments,
+    )
+    from openhands.core.logger import openhands_logger as logger
+    from openhands.core.main import create_runtime, run_controller
+    from openhands.events.action import CmdRunAction
+    from openhands.events.observation import CmdOutputObservation, ErrorObservation
+    from openhands.runtime.runtime import Runtime
+   ```
+
+2. Crie uma configuração:
+   ```python
+   def get_config(instance: pd.Series, metadata: EvalMetadata) -> AppConfig:
+       config = AppConfig(
+           default_agent=metadata.agent_class,
+           runtime='docker',
+           max_iterations=metadata.max_iterations,
+           sandbox=SandboxConfig(
+               base_container_image='your_container_image',
+               enable_auto_lint=True,
+               timeout=300,
+           ),
+       )
+       config.set_llm_config(metadata.llm_config)
+       return config
+   ```
+
+3. Inicialize o ambiente de execução e configure o ambiente de avaliação:
+   ```python
+   def initialize_runtime(runtime: Runtime, instance: pd.Series):
+       # Configure seu ambiente de avaliação aqui
+       # Por exemplo, definindo variáveis de ambiente, preparando arquivos, etc.
+       pass
+   ```
+
+4. Crie uma função para processar cada instância:
+   ```python
+   from openhands.utils.async_utils import call_async_from_sync
+   def process_instance(instance: pd.Series, metadata: EvalMetadata) -> EvalOutput:
+       config = get_config(instance, metadata)
+       runtime = create_runtime(config)
+       call_async_from_sync(runtime.connect)
+       initialize_runtime(runtime, instance)
+
+       instruction = get_instruction(instance, metadata)
+
+       state = run_controller(
+           config=config,
+           task_str=instruction,
+           runtime=runtime,
+           fake_user_response_fn=your_user_response_function,
+       )
+
+       # Avalie as ações do agente
+       evaluation_result = await evaluate_agent_actions(runtime, instance)
+
+       return EvalOutput(
+           instance_id=instance.instance_id,
+           instruction=instruction,
+           test_result=evaluation_result,
+           metadata=metadata,
+           history=compatibility_for_eval_history_pairs(state.history),
+           metrics=state.metrics.get() if state.metrics else None,
+           error=state.last_error if state and state.last_error else None,
+       )
+   ```
+
+5. Execute a avaliação:
+   ```python
+   metadata = make_metadata(llm_config, dataset_name, agent_class, max_iterations, eval_note, eval_output_dir)
+   output_file = os.path.join(metadata.eval_output_dir, 'output.jsonl')
+   instances = prepare_dataset(your_dataset, output_file, eval_n_limit)
+
+   await run_evaluation(
+       instances,
+       metadata,
+       output_file,
+       num_workers,
+       process_instance
+   )
+   ```
+
+Este fluxo de trabalho configura a configuração, inicializa o ambiente de execução, processa cada instância executando o agente e avaliando suas ações e, em seguida, coleta os resultados em um objeto `EvalOutput`. A função `run_evaluation` lida com a paralelização e o rastreamento do progresso.
+
+Lembre-se de personalizar as funções `get_instruction`, `your_user_response_function` e `evaluate_agent_actions` de acordo com os requisitos específicos do seu benchmark.
+
+Ao seguir essa estrutura, você pode criar um fluxo de trabalho de avaliação robusto para o seu benchmark dentro do framework OpenHands.
+
+
+## Entendendo a `user_response_fn`
+
+A `user_response_fn` é um componente crucial no fluxo de trabalho de avaliação do OpenHands. Ela simula a interação do usuário com o agente, permitindo respostas automatizadas durante o processo de avaliação. Essa função é particularmente útil quando você deseja fornecer respostas consistentes e predefinidas às consultas ou ações do agente.
+
+
+### Fluxo de Trabalho e Interação
+
+O fluxo de trabalho correto para lidar com ações e a `user_response_fn` é o seguinte:
+
+1. O agente recebe uma tarefa e começa a processar
+2. O agente emite uma Ação
+3. Se a Ação for executável (por exemplo, CmdRunAction, IPythonRunCellAction):
+   - O Runtime processa a Ação
+   - O Runtime retorna uma Observação
+4. Se a Ação não for executável (normalmente uma MessageAction):
+   - A `user_response_fn` é chamada
+   - Ela retorna uma resposta simulada do usuário
+5. O agente recebe a Observação ou a resposta simulada
+6. As etapas 2-5 se repetem até que a tarefa seja concluída ou o número máximo de iterações seja atingido
+
+Aqui está uma representação visual mais precisa:
+
+```
+                 [Agente]
+                    |
+                    v
+               [Emitir Ação]
+                    |
+                    v
+            [A Ação é Executável?]
+           /                       \
+         Sim                        Não
+          |                          |
+          v                          v
+     [Runtime]               [user_response_fn]
+          |                          |
+          v                          v
+  [Retornar Observação]    [Resposta Simulada]
+           \                        /
+            \                      /
+             v                    v
+           [Agente recebe feedback]
+                    |
+                    v
+         [Continuar ou Concluir Tarefa]
+```
+
+Neste fluxo de trabalho:
+
+- Ações executáveis (como executar comandos ou código) são tratadas diretamente pelo Runtime
+- Ações não executáveis (normalmente quando o agente deseja se comunicar ou pedir esclarecimentos) são tratadas pela `user_response_fn`
+- O agente então processa o feedback, seja uma Observação do Runtime ou uma resposta simulada da `user_response_fn`
+
+Essa abordagem permite o tratamento automatizado de ações concretas e interações simuladas do usuário, tornando-a adequada para cenários de avaliação em que você deseja testar a capacidade do agente de concluir tarefas com intervenção humana mínima.
+
+### Exemplo de Implementação
+
+Aqui está um exemplo de uma `user_response_fn` usada na avaliação SWE-Bench:
+
+```python
+def codeact_user_response(state: State | None) -> str:
+    msg = (
+        'Please continue working on the task on whatever approach you think is suitable.\n'
+        'If you think you have solved the task, please first send your answer to user through message and then <execute_bash> exit </execute_bash>.\n'
+        'IMPORTANT: YOU SHOULD NEVER ASK FOR HUMAN HELP.\n'
+    )
+
+    if state and state.history:
+        # check if the agent has tried to talk to the user 3 times, if so, let the agent know it can give up
+        user_msgs = [
+            event
+            for event in state.history
+            if isinstance(event, MessageAction) and event.source == 'user'
+        ]
+        if len(user_msgs) >= 2:
+            # let the agent know that it can give up when it has tried 3 times
+            return (
+                msg
+                + 'If you want to give up, run: <execute_bash> exit </execute_bash>.\n'
+            )
+    return msg
+```
+
+Esta função faz o seguinte:
+
+1. Fornece uma mensagem padrão encorajando o agente a continuar trabalhando
+2. Verifica quantas vezes o agente tentou se comunicar com o usuário
+3. Se o agente fez várias tentativas, fornece uma opção para desistir
+
+Ao usar essa função, você pode garantir um comportamento consistente em várias execuções de avaliação e evitar que o agente fique preso esperando a entrada do usuário.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/github-action.md

@@ -0,0 +1,50 @@
+# Usando a Ação do GitHub OpenHands
+
+Este guia explica como usar a Ação do GitHub OpenHands, tanto dentro do repositório OpenHands quanto em seus próprios projetos.
+
+## Usando a Ação no Repositório OpenHands
+
+Para usar a Ação do GitHub OpenHands em um repositório, você pode:
+
+1. Criar uma issue no repositório.
+2. Adicionar a etiqueta `fix-me` à issue ou deixar um comentário na issue começando com `@openhands-agent`.
+
+A ação será acionada automaticamente e tentará resolver a issue.
+
+## Instalando a Ação em um Novo Repositório
+
+Para instalar a Ação do GitHub OpenHands em seu próprio repositório, siga o [README para o OpenHands Resolver](https://github.com/All-Hands-AI/OpenHands/blob/main/openhands/resolver/README.md).
+
+## Dicas de Uso
+
+### Resolução Iterativa
+
+1. Crie uma issue no repositório.
+2. Adicione a etiqueta `fix-me` à issue ou deixe um comentário começando com `@openhands-agent`.
+3. Revise a tentativa de resolver a issue verificando o pull request.
+4. Faça um acompanhamento com feedback por meio de comentários gerais, comentários de revisão ou comentários de thread inline.
+5. Adicione a etiqueta `fix-me` ao pull request ou aborde um comentário específico começando com `@openhands-agent`.
+
+### Etiqueta versus Macro
+
+- Etiqueta (`fix-me`): Solicita ao OpenHands que aborde a issue ou pull request **inteiro**.
+- Macro (`@openhands-agent`): Solicita ao OpenHands que considere apenas a descrição da issue/pull request e **o comentário específico**.
+
+## Configurações Avançadas
+
+### Adicionar configurações personalizadas do repositório
+
+Você pode fornecer instruções personalizadas para o OpenHands seguindo o [README para o resolver](https://github.com/All-Hands-AI/OpenHands/blob/main/openhands/resolver/README.md#providing-custom-instructions).
+
+### Configurações personalizadas
+
+O GitHub resolver verificará automaticamente se há [segredos do repositório](https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions?tool=webui#creating-secrets-for-a-repository) ou [variáveis do repositório](https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/store-information-in-variables#creating-configuration-variables-for-a-repository) válidos para personalizar seu comportamento.
+As opções de personalização que você pode definir são:
+
+| **Nome do atributo**             | **Tipo** | **Finalidade**                                                                                       | **Exemplo**                                        |
+| -------------------------------- | -------- | --------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
+| `LLM_MODEL`                      | Variável | Definir o LLM a ser usado com o OpenHands                                                           | `LLM_MODEL="anthropic/claude-3-5-sonnet-20241022"` |
+| `OPENHANDS_MAX_ITER`             | Variável | Definir o limite máximo de iterações do agente                                                      | `OPENHANDS_MAX_ITER=10`                            |
+| `OPENHANDS_MACRO`                | Variável | Personalizar a macro padrão para invocar o resolver                                                 | `OPENHANDS_MACRO=@resolveit`                       |
+| `OPENHANDS_BASE_CONTAINER_IMAGE` | Variável | Sandbox personalizado ([saiba mais](https://docs.all-hands.dev/modules/usage/how-to/custom-sandbox-guide)) | `OPENHANDS_BASE_CONTAINER_IMAGE="custom_image"`    |
+| `TARGET_BRANCH`                  | Variável | Mesclar em um branch diferente de `main`                                                            | `TARGET_BRANCH="dev"`                              |

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/gui-mode.md

@@ -0,0 +1,118 @@
+# Modo GUI
+
+O OpenHands fornece um modo de Interface Gráfica do Usuário (GUI) para interagir com o assistente de IA.
+
+## Instalação e Configuração
+
+1. Siga as instruções de instalação para instalar o OpenHands.
+2. Após executar o comando, acesse o OpenHands em [http://localhost:3000](http://localhost:3000).
+
+## Interagindo com a GUI
+
+### Configuração Inicial
+
+1. No primeiro lançamento, você verá uma página de configurações.
+2. Selecione um `Provedor de LLM` e um `Modelo de LLM` nos menus suspensos. Se o modelo necessário não existir na lista,
+   ative as opções `Avançadas` e insira-o com o prefixo correto na caixa de texto `Modelo Personalizado`.
+3. Insira a `Chave de API` correspondente para o provedor escolhido.
+4. Clique em `Salvar Alterações` para aplicar as configurações.
+
+### Configuração do Token do GitHub
+
+O OpenHands exporta automaticamente um `GITHUB_TOKEN` para o ambiente shell se ele estiver disponível. Isso pode acontecer de duas maneiras:
+
+**Instalação Local**: O usuário insere diretamente seu token do GitHub.
+<details>
+  <summary>Configurando um Token do GitHub</summary>
+
+  1. **Gere um Personal Access Token (PAT)**:
+   - No GitHub, vá para Settings > Developer Settings > Personal Access Tokens > Tokens (classic).
+   - **New token (classic)**
+     - Escopos necessários:
+     - `repo` (Controle total de repositórios privados)
+   - **Fine-Grained Tokens**
+     - All Repositories (Você pode selecionar repositórios específicos, mas isso afetará o que retorna na pesquisa de repositórios)
+     - Minimal Permissions (Selecione **Meta Data = Read-only** para pesquisa, **Pull Requests = Read and Write**, **Content = Read and Write** para criação de branches)
+  2. **Insira o Token no OpenHands**:
+   - Clique no botão Settings (ícone de engrenagem).
+   - Navegue até a seção `GitHub Settings`.
+   - Cole seu token no campo `GitHub Token`.
+   - Clique em `Save Changes` para aplicar as alterações.
+</details>
+
+<details>
+  <summary>Políticas de Token Organizacional</summary>
+
+  Se você estiver trabalhando com repositórios organizacionais, configurações adicionais podem ser necessárias:
+
+  1. **Verifique os Requisitos da Organização**:
+   - Os administradores da organização podem impor políticas específicas de token.
+   - Algumas organizações exigem que os tokens sejam criados com SSO habilitado.
+   - Revise as [configurações de política de token](https://docs.github.com/en/organizations/managing-programmatic-access-to-your-organization/setting-a-personal-access-token-policy-for-your-organization) da sua organização.
+  2. **Verifique o Acesso à Organização**:
+   - Vá para as configurações do seu token no GitHub.
+   - Procure a organização em `Organization access`.
+   - Se necessário, clique em `Enable SSO` ao lado da sua organização.
+   - Conclua o processo de autorização SSO.
+</details>
+
+<details>
+  <summary>Solução de Problemas</summary>
+
+  Problemas comuns e soluções:
+
+  - **Token Não Reconhecido**:
+     - Certifique-se de que o token esteja salvo corretamente nas configurações.
+     - Verifique se o token não expirou.
+     - Verifique se o token possui os escopos necessários.
+     - Tente regenerar o token.
+
+  - **Acesso à Organização Negado**:
+     - Verifique se o SSO é necessário, mas não está habilitado.
+     - Verifique a associação à organização.
+     - Entre em contato com o administrador da organização se as políticas de token estiverem bloqueando o acesso.
+
+  - **Verificando se o Token Funciona**:
+     - O aplicativo mostrará uma marca de seleção verde se o token for válido.
+     - Tente acessar um repositório para confirmar as permissões.
+     - Verifique o console do navegador em busca de mensagens de erro.
+</details>
+
+**OpenHands Cloud**: O token é obtido por meio da autenticação OAuth do GitHub.
+
+<details>
+  <summary>Autenticação OAuth</summary>
+
+  Ao usar o OpenHands Cloud, o fluxo OAuth do GitHub solicita as seguintes permissões:
+   - Acesso ao repositório (leitura/escrita)
+   - Gerenciamento de fluxo de trabalho
+   - Acesso de leitura à organização
+
+  Para autenticar o OpenHands:
+   - Clique em `Sign in with GitHub` quando solicitado.
+   - Revise as permissões solicitadas.
+   - Autorize o OpenHands a acessar sua conta do GitHub.
+   - Se estiver usando uma organização, autorize o acesso à organização se solicitado.
+</details>
+
+### Configurações Avançadas
+
+1. Dentro da página Settings, ative as opções `Advanced` para acessar configurações adicionais.
+2. Use a caixa de texto `Custom Model` para inserir manualmente um modelo se ele não estiver na lista.
+3. Especifique uma `Base URL` se necessário para o seu provedor de LLM.
+
+### Interagindo com a IA
+
+1. Digite seu prompt na caixa de entrada.
+2. Clique no botão de envio ou pressione Enter para enviar sua mensagem.
+3. A IA processará sua entrada e fornecerá uma resposta na janela de chat.
+4. Você pode continuar a conversa fazendo perguntas de acompanhamento ou fornecendo informações adicionais.
+
+## Dicas para Uso Eficaz
+
+- Seja específico em suas solicitações para obter as respostas mais precisas e úteis, conforme descrito nas [melhores práticas de prompting](../prompting/prompting-best-practices).
+- Use o painel de workspace para explorar a estrutura do seu projeto.
+- Use um dos modelos recomendados, conforme descrito na seção [LLMs](usage/llms/llms.md).
+
+Lembre-se, o modo GUI do OpenHands é projetado para tornar sua interação com o assistente de IA o mais suave e intuitiva
+possível. Não hesite em explorar seus recursos para maximizar sua produtividade.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/how-to/headless-mode.md

@@ -0,0 +1,56 @@
+# Modo Headless
+
+Você pode executar o OpenHands com um único comando, sem iniciar a aplicação web.
+Isso facilita a escrita de scripts e a automação de tarefas com o OpenHands.
+
+Isso é diferente do [Modo CLI](cli-mode), que é interativo e melhor para desenvolvimento ativo.
+
+## Com Python
+
+Para executar o OpenHands no modo headless com Python:
+1. Certifique-se de ter seguido as [instruções de configuração de desenvolvimento](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
+2. Execute o seguinte comando:
+```bash
+poetry run python -m openhands.core.main -t "escreva um script bash que imprima oi"
+```
+
+Você precisará definir seu modelo, chave de API e outras configurações por meio de variáveis de ambiente
+[ou do arquivo `config.toml`](https://github.com/All-Hands-AI/OpenHands/blob/main/config.template.toml).
+
+## Com Docker
+
+Para executar o OpenHands no modo Headless com Docker:
+
+1. Defina as seguintes variáveis de ambiente no seu terminal:
+
+- `WORKSPACE_BASE` para o diretório que você deseja que o OpenHands edite (Ex: `export WORKSPACE_BASE=$(pwd)/workspace`).
+- `LLM_MODEL` para o modelo a ser usado (Ex: `export LLM_MODEL="anthropic/claude-3-5-sonnet-20241022"`).
+- `LLM_API_KEY` para a chave de API (Ex: `export LLM_API_KEY="sk_test_12345"`).
+
+2. Execute o seguinte comando Docker:
+
+```bash
+docker run -it \
+    --pull=always \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
+    -e SANDBOX_USER_ID=$(id -u) \
+    -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
+    -e LLM_API_KEY=$LLM_API_KEY \
+    -e LLM_MODEL=$LLM_MODEL \
+    -e LOG_ALL_EVENTS=true \
+    -v $WORKSPACE_BASE:/opt/workspace_base \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    -v ~/.openhands-state:/.openhands-state \
+    --add-host host.docker.internal:host-gateway \
+    --name openhands-app-$(date +%Y%m%d%H%M%S) \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29 \
+    python -m openhands.core.main -t "escreva um script bash que imprima oi"
+```
+
+## Configurações Avançadas do Headless
+
+Para visualizar todas as opções de configuração disponíveis para o modo headless, execute o comando Python com a flag `--help`.
+
+### Logs Adicionais
+
+Para que o modo headless registre todas as ações do agente, execute no terminal: `export LOG_ALL_EVENTS=true`

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/installation.mdx

@@ -0,0 +1,104 @@
+# Executando o OpenHands
+
+## Requisitos do Sistema
+
+- MacOS com [suporte ao Docker Desktop](https://docs.docker.com/desktop/setup/install/mac-install/#system-requirements)
+- Linux
+- Windows com [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) e [suporte ao Docker Desktop](https://docs.docker.com/desktop/setup/install/windows-install/#system-requirements)
+
+É recomendado um sistema com um processador moderno e um mínimo de **4GB de RAM** para executar o OpenHands.
+
+## Pré-requisitos
+
+<details>
+  <summary>MacOS</summary>
+
+  **Docker Desktop**
+
+  1. [Instale o Docker Desktop no Mac](https://docs.docker.com/desktop/setup/install/mac-install).
+  2. Abra o Docker Desktop, vá em `Settings > Advanced` e certifique-se de que `Allow the default Docker socket to be used` esteja habilitado.
+</details>
+
+<details>
+  <summary>Linux</summary>
+
+  :::note
+  Testado com Ubuntu 22.04.
+  :::
+
+  **Docker Desktop**
+
+  1. [Instale o Docker Desktop no Linux](https://docs.docker.com/desktop/setup/install/linux/).
+
+</details>
+
+<details>
+  <summary>Windows</summary>
+
+  **WSL**
+
+  1. [Instale o WSL](https://learn.microsoft.com/en-us/windows/wsl/install).
+  2. Execute `wsl --version` no powershell e confirme `Default Version: 2`.
+
+  **Docker Desktop**
+
+  1. [Instale o Docker Desktop no Windows](https://docs.docker.com/desktop/setup/install/windows-install).
+  2. Abra o Docker Desktop, vá em `Settings` e confirme o seguinte:
+  - General: `Use the WSL 2 based engine` está habilitado.
+  - Resources > WSL Integration: `Enable integration with my default WSL distro` está habilitado.
+
+  :::note
+  O comando docker abaixo para iniciar o aplicativo deve ser executado dentro do terminal WSL.
+  :::
+
+</details>
+
+## Inicie o Aplicativo
+
+A maneira mais fácil de executar o OpenHands é no Docker.
+
+```bash
+docker pull docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik
+
+docker run -it --rm --pull=always \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
+    -e LOG_ALL_EVENTS=true \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    -v ~/.openhands-state:/.openhands-state \
+    -p 3000:3000 \
+    --add-host host.docker.internal:host-gateway \
+    --name openhands-app \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29
+```
+
+Você encontrará o OpenHands em execução em http://localhost:3000!
+
+Você também pode [conectar o OpenHands ao seu sistema de arquivos local](https://docs.all-hands.dev/modules/usage/runtimes#connecting-to-your-filesystem),
+executar o OpenHands em um [modo headless programável](https://docs.all-hands.dev/modules/usage/how-to/headless-mode),
+interagir com ele através de uma [CLI amigável](https://docs.all-hands.dev/modules/usage/how-to/cli-mode),
+ou executá-lo em issues marcadas com [uma ação do GitHub](https://docs.all-hands.dev/modules/usage/how-to/github-action).
+
+## Configuração
+
+Ao iniciar o OpenHands, você verá uma página de Configurações. Você **deve** selecionar um `LLM Provider` e `LLM Model` e inserir uma `API Key` correspondente.
+Estes podem ser alterados a qualquer momento selecionando o botão `Settings` (ícone de engrenagem) na interface do usuário.
+
+Se o modelo necessário não existir na lista, você pode ativar as opções `Advanced` e inseri-lo manualmente com o prefixo correto
+na caixa de texto `Custom Model`.
+As opções `Advanced` também permitem que você especifique uma `Base URL`, se necessário.
+
+Agora você está pronto para [começar com o OpenHands](./getting-started).
+
+## Versões
+
+O [comando docker acima](./installation#start-the-app) baixa a versão estável mais recente do OpenHands. Você também tem outras opções:
+- Para uma versão específica, substitua $VERSION em `openhands:$VERSION` e `runtime:$VERSION`, com o número da versão.
+Usamos SemVer, então `0.9` apontará automaticamente para a versão mais recente `0.9.x`, e `0` apontará para a versão mais recente `0.x.x`.
+- Para a versão de desenvolvimento mais atualizada, substitua $VERSION em `openhands:$VERSION` e `runtime:$VERSION`, por `main`.
+Esta versão é instável e é recomendada apenas para fins de teste ou desenvolvimento.
+
+Você pode escolher a tag que melhor se adapta às suas necessidades com base nos requisitos de estabilidade e recursos desejados.
+
+Para o fluxo de trabalho de desenvolvimento, consulte [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
+
+Está tendo problemas? Confira nosso [Guia de Solução de Problemas](https://docs.all-hands.dev/modules/usage/troubleshooting).

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/azure-llms.md

@@ -0,0 +1,41 @@
+# Azure
+
+O OpenHands usa o LiteLLM para fazer chamadas para os modelos de chat do Azure. Você pode encontrar a documentação sobre como usar o Azure como provedor [aqui](https://docs.litellm.ai/docs/providers/azure).
+
+## Configuração do Azure OpenAI
+
+Ao executar o OpenHands, você precisará definir a seguinte variável de ambiente usando `-e` no
+[comando docker run](../installation#running-openhands):
+
+```
+LLM_API_VERSION="<api-version>"              # por exemplo, "2023-05-15"
+```
+
+Exemplo:
+```bash
+docker run -it --pull=always \
+    -e LLM_API_VERSION="2023-05-15"
+    ...
+```
+
+Então, nas configurações da interface do usuário do OpenHands:
+
+:::note
+Você precisará do nome da sua implantação do ChatGPT, que pode ser encontrado na página de implantações no Azure. Isso é referenciado como
+&lt;deployment-name&gt; abaixo.
+:::
+
+1. Habilite as opções `Advanced`
+2. Defina o seguinte:
+   - `Custom Model` para azure/&lt;deployment-name&gt;
+   - `Base URL` para a URL base da sua API do Azure (por exemplo, `https://example-endpoint.openai.azure.com`)
+   - `API Key` para a sua chave de API do Azure
+
+### Configuração do Azure OpenAI
+
+Ao executar o OpenHands, defina a seguinte variável de ambiente usando `-e` no
+[comando docker run](../installation#running-openhands):
+
+```
+LLM_API_VERSION="<api-version>"                                    # por exemplo, "2024-02-15-preview"
+```

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/custom-llm-configs.md

@@ -0,0 +1,136 @@
+# Configurações Personalizadas de LLM
+
+O OpenHands suporta a definição de múltiplas configurações nomeadas de LLM no seu arquivo `config.toml`. Este recurso permite que você use diferentes configurações de LLM para diferentes propósitos, como usar um modelo mais barato para tarefas que não exigem respostas de alta qualidade, ou usar diferentes modelos com diferentes parâmetros para agentes específicos.
+
+## Como Funciona
+
+As configurações nomeadas de LLM são definidas no arquivo `config.toml` usando seções que começam com `llm.`. Por exemplo:
+
+```toml
+# Configuração padrão de LLM
+[llm]
+model = "gpt-4"
+api_key = "your-api-key"
+temperature = 0.0
+
+# Configuração personalizada de LLM para um modelo mais barato
+[llm.gpt3]
+model = "gpt-3.5-turbo"
+api_key = "your-api-key"
+temperature = 0.2
+
+# Outra configuração personalizada com parâmetros diferentes
+[llm.high-creativity]
+model = "gpt-4"
+api_key = "your-api-key"
+temperature = 0.8
+top_p = 0.9
+```
+
+Cada configuração nomeada herda todas as configurações da seção padrão `[llm]` e pode sobrescrever qualquer uma dessas configurações. Você pode definir quantas configurações personalizadas forem necessárias.
+
+## Usando Configurações Personalizadas
+
+### Com Agentes
+
+Você pode especificar qual configuração de LLM um agente deve usar definindo o parâmetro `llm_config` na seção de configuração do agente:
+
+```toml
+[agent.RepoExplorerAgent]
+# Usa a configuração mais barata do GPT-3 para este agente
+llm_config = 'gpt3'
+
+[agent.CodeWriterAgent]
+# Usa a configuração de alta criatividade para este agente
+llm_config = 'high-creativity'
+```
+
+### Opções de Configuração
+
+Cada configuração nomeada de LLM suporta todas as mesmas opções que a configuração padrão de LLM. Isso inclui:
+
+- Seleção de modelo (`model`)
+- Configuração da API (`api_key`, `base_url`, etc.)
+- Parâmetros do modelo (`temperature`, `top_p`, etc.)
+- Configurações de repetição (`num_retries`, `retry_multiplier`, etc.)
+- Limites de tokens (`max_input_tokens`, `max_output_tokens`)
+- E todas as outras opções de configuração de LLM
+
+Para uma lista completa das opções disponíveis, consulte a seção Configuração de LLM na documentação de [Opções de Configuração](../configuration-options).
+
+## Casos de Uso
+
+As configurações personalizadas de LLM são particularmente úteis em vários cenários:
+
+- **Otimização de Custos**: Use modelos mais baratos para tarefas que não exigem respostas de alta qualidade, como exploração de repositório ou operações simples de arquivos.
+- **Ajuste Específico de Tarefas**: Configure diferentes valores de temperature e top_p para tarefas que exigem diferentes níveis de criatividade ou determinismo.
+- **Diferentes Provedores**: Use diferentes provedores de LLM ou endpoints de API para diferentes tarefas.
+- **Testes e Desenvolvimento**: Alterne facilmente entre diferentes configurações de modelo durante o desenvolvimento e testes.
+
+## Exemplo: Otimização de Custos
+
+Um exemplo prático de uso de configurações personalizadas de LLM para otimizar custos:
+
+```toml
+# Configuração padrão usando GPT-4 para respostas de alta qualidade
+[llm]
+model = "gpt-4"
+api_key = "your-api-key"
+temperature = 0.0
+
+# Configuração mais barata para exploração de repositório
+[llm.repo-explorer]
+model = "gpt-3.5-turbo"
+temperature = 0.2
+
+# Configuração para geração de código
+[llm.code-gen]
+model = "gpt-4"
+temperature = 0.0
+max_output_tokens = 2000
+
+[agent.RepoExplorerAgent]
+llm_config = 'repo-explorer'
+
+[agent.CodeWriterAgent]
+llm_config = 'code-gen'
+```
+
+Neste exemplo:
+- A exploração de repositório usa um modelo mais barato, pois envolve principalmente entender e navegar pelo código
+- A geração de código usa GPT-4 com um limite maior de tokens para gerar blocos de código maiores
+- A configuração padrão permanece disponível para outras tarefas
+
+# Configurações Personalizadas com Nomes Reservados
+
+O OpenHands pode usar configurações personalizadas de LLM nomeadas com nomes reservados, para casos de uso específicos. Se você especificar o modelo e outras configurações sob os nomes reservados, então o OpenHands irá carregá-los e usá-los para um propósito específico. Até agora, uma dessas configurações está implementada: editor de rascunho.
+
+## Configuração do Editor de Rascunho
+
+A configuração `draft_editor` é um grupo de configurações que você pode fornecer, para especificar o modelo a ser usado para a elaboração preliminar de edições de código, para quaisquer tarefas que envolvam edição e refinamento de código. Você precisa fornecê-la na seção `[llm.draft_editor]`.
+
+Por exemplo, você pode definir em `config.toml` um editor de rascunho assim:
+
+```toml
+[llm.draft_editor]
+model = "gpt-4"
+temperature = 0.2
+top_p = 0.95
+presence_penalty = 0.0
+frequency_penalty = 0.0
+```
+
+Esta configuração:
+- Usa GPT-4 para edições e sugestões de alta qualidade
+- Define uma temperatura baixa (0,2) para manter a consistência, permitindo alguma flexibilidade
+- Usa um valor alto de top_p (0,95) para considerar uma ampla gama de opções de tokens
+- Desativa as penalidades de presença e frequência para manter o foco nas edições específicas necessárias
+
+Use esta configuração quando quiser que um LLM faça um rascunho das edições antes de realizá-las. Em geral, pode ser útil para:
+- Revisar e sugerir melhorias de código
+- Refinar o conteúdo existente, mantendo seu significado principal
+- Fazer alterações precisas e focadas no código ou texto
+
+:::note
+As configurações personalizadas de LLM estão disponíveis apenas quando se usa o OpenHands no modo de desenvolvimento, via `main.py` ou `cli.py`. Ao executar via `docker run`, por favor, use as opções de configuração padrão.
+:::

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/google-llms.md

@@ -0,0 +1,29 @@
+# Google Gemini/Vertex
+
+O OpenHands usa o LiteLLM para fazer chamadas aos modelos de chat do Google. Você pode encontrar a documentação sobre como usar o Google como provedor:
+
+- [Gemini - Google AI Studio](https://docs.litellm.ai/docs/providers/gemini)
+- [VertexAI - Google Cloud Platform](https://docs.litellm.ai/docs/providers/vertex)
+
+## Configurações do Gemini - Google AI Studio
+
+Ao executar o OpenHands, você precisará definir o seguinte na interface do usuário do OpenHands através das Configurações:
+- `LLM Provider` para `Gemini`
+- `LLM Model` para o modelo que você usará.
+Se o modelo não estiver na lista, ative as opções `Advanced` e insira-o em `Custom Model` (por exemplo, gemini/<model-name> como `gemini/gemini-1.5-pro`).
+- `API Key` para sua chave de API do Gemini
+
+## Configurações do VertexAI - Google Cloud Platform
+
+Para usar o Vertex AI através do Google Cloud Platform ao executar o OpenHands, você precisará definir as seguintes variáveis de ambiente usando `-e` no [comando docker run](../installation#running-openhands):
+
+```
+GOOGLE_APPLICATION_CREDENTIALS="<json-dump-of-gcp-service-account-json>"
+VERTEXAI_PROJECT="<your-gcp-project-id>"
+VERTEXAI_LOCATION="<your-gcp-location>"
+```
+
+Em seguida, defina o seguinte na interface do usuário do OpenHands através das Configurações:
+- `LLM Provider` para `VertexAI`
+- `LLM Model` para o modelo que você usará.
+Se o modelo não estiver na lista, ative as opções `Advanced` e insira-o em `Custom Model` (por exemplo, vertex_ai/&lt;model-name&gt;).

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/groq.md

@@ -0,0 +1,21 @@
+# Groq
+
+O OpenHands usa o LiteLLM para fazer chamadas para modelos de chat no Groq. Você pode encontrar a documentação deles sobre como usar o Groq como provedor [aqui](https://docs.litellm.ai/docs/providers/groq).
+
+## Configuração
+
+Ao executar o OpenHands, você precisará definir o seguinte na interface do usuário do OpenHands através das Configurações:
+- `LLM Provider` para `Groq`
+- `LLM Model` para o modelo que você usará. [Visite aqui para ver a lista de modelos que o Groq hospeda](https://console.groq.com/docs/models). Se o modelo não estiver na lista, ative as opções `Advanced` e insira-o em `Custom Model` (por exemplo, groq/<model-name> como `groq/llama3-70b-8192`).
+- `API key` para sua chave de API do Groq. Para encontrar ou criar sua chave de API do Groq, [veja aqui](https://console.groq.com/keys).
+
+
+
+## Usando o Groq como um Endpoint Compatível com OpenAI
+
+O endpoint do Groq para conclusão de chat é [em grande parte compatível com OpenAI](https://console.groq.com/docs/openai). Portanto, você pode acessar os modelos do Groq como acessaria qualquer endpoint compatível com OpenAI. Na interface do usuário do OpenHands, através das Configurações:
+1. Habilite as opções `Advanced`
+2. Defina o seguinte:
+   - `Custom Model` para o prefixo `openai/` + o modelo que você usará (por exemplo, `openai/llama3-70b-8192`)
+   - `Base URL` para `https://api.groq.com/openai/v1`
+   - `API Key` para sua chave de API do Groq

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/litellm-proxy.md

@@ -0,0 +1,22 @@
+Here is the translation to Brazilian Portuguese:
+
+# Proxy LiteLLM
+
+O OpenHands suporta o uso do [proxy LiteLLM](https://docs.litellm.ai/docs/proxy/quick_start) para acessar vários provedores de LLM.
+
+## Configuração
+
+Para usar o proxy LiteLLM com o OpenHands, você precisa:
+
+1. Configurar um servidor proxy LiteLLM (veja a [documentação do LiteLLM](https://docs.litellm.ai/docs/proxy/quick_start))
+2. Ao executar o OpenHands, você precisará definir o seguinte na interface do usuário do OpenHands através das Configurações:
+  * Habilitar opções `Avançadas`
+  * `Modelo Personalizado` para o prefixo `litellm_proxy/` + o modelo que você usará (por exemplo, `litellm_proxy/anthropic.claude-3-5-sonnet-20241022-v2:0`)
+  * `URL Base` para a URL do seu proxy LiteLLM (por exemplo, `https://your-litellm-proxy.com`)
+  * `Chave de API` para a chave de API do seu proxy LiteLLM
+
+## Modelos Suportados
+
+Os modelos suportados dependem da configuração do seu proxy LiteLLM. O OpenHands suporta qualquer modelo que o seu proxy LiteLLM esteja configurado para lidar.
+
+Consulte a configuração do seu proxy LiteLLM para obter a lista de modelos disponíveis e seus nomes.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/llms.md

@@ -0,0 +1,72 @@
+# 🤖 Backends de LLM
+
+O OpenHands pode se conectar a qualquer LLM suportado pelo LiteLLM. No entanto, ele requer um modelo poderoso para funcionar.
+
+## Recomendações de Modelo
+
+Com base em nossas avaliações de modelos de linguagem para tarefas de codificação (usando o conjunto de dados SWE-bench), podemos fornecer algumas recomendações para a seleção de modelos. Nossos resultados mais recentes de benchmarking podem ser encontrados nesta [planilha](https://docs.google.com/spreadsheets/d/1wOUdFCMyY6Nt0AIqF705KN4JKOWgeI4wUGUP60krXXs/edit?gid=0).
+
+Com base nessas descobertas e no feedback da comunidade, os seguintes modelos foram verificados como funcionando razoavelmente bem com o OpenHands:
+
+- anthropic/claude-3-5-sonnet-20241022 (recomendado)
+- anthropic/claude-3-5-haiku-20241022
+- deepseek/deepseek-chat
+- gpt-4o
+
+:::warning
+O OpenHands enviará muitos prompts para o LLM que você configurar. A maioria desses LLMs custa dinheiro, então certifique-se de definir limites de gastos e monitorar o uso.
+:::
+
+Para obter uma lista completa dos provedores e modelos disponíveis, consulte a [documentação do litellm](https://docs.litellm.ai/docs/providers).
+
+:::note
+A maioria dos modelos locais e de código aberto atuais não são tão poderosos. Ao usar esses modelos, você pode ver longos tempos de espera entre as mensagens, respostas ruins ou erros sobre JSON malformado. O OpenHands só pode ser tão poderoso quanto os modelos que o impulsionam. No entanto, se você encontrar alguns que funcionem, adicione-os à lista verificada acima.
+:::
+
+## Configuração do LLM
+
+O seguinte pode ser definido na interface do usuário do OpenHands por meio das Configurações:
+
+- `Provedor LLM`
+- `Modelo LLM`
+- `Chave API`
+- `URL Base` (através das configurações `Avançadas`)
+
+Existem algumas configurações que podem ser necessárias para alguns LLMs/provedores que não podem ser definidas através da interface do usuário. Em vez disso, elas podem ser definidas por meio de variáveis de ambiente passadas para o comando docker run ao iniciar o aplicativo usando `-e`:
+
+- `LLM_API_VERSION`
+- `LLM_EMBEDDING_MODEL`
+- `LLM_EMBEDDING_DEPLOYMENT_NAME`
+- `LLM_DROP_PARAMS`
+- `LLM_DISABLE_VISION`
+- `LLM_CACHING_PROMPT`
+
+Temos alguns guias para executar o OpenHands com provedores de modelo específicos:
+
+- [Azure](llms/azure-llms)
+- [Google](llms/google-llms)
+- [Groq](llms/groq)
+- [LiteLLM Proxy](llms/litellm-proxy)
+- [OpenAI](llms/openai-llms)
+- [OpenRouter](llms/openrouter)
+
+### Novas tentativas de API e limites de taxa
+
+Os provedores de LLM normalmente têm limites de taxa, às vezes muito baixos, e podem exigir novas tentativas. O OpenHands tentará automaticamente as solicitações novamente se receber um Erro de Limite de Taxa (código de erro 429).
+
+Você pode personalizar essas opções conforme necessário para o provedor que está usando. Verifique a documentação deles e defina as seguintes variáveis de ambiente para controlar o número de novas tentativas e o tempo entre as novas tentativas:
+
+- `LLM_NUM_RETRIES` (Padrão de 4 vezes)
+- `LLM_RETRY_MIN_WAIT` (Padrão de 5 segundos)
+- `LLM_RETRY_MAX_WAIT` (Padrão de 30 segundos)
+- `LLM_RETRY_MULTIPLIER` (Padrão de 2)
+
+Se você estiver executando o OpenHands no modo de desenvolvimento, também poderá definir essas opções no arquivo `config.toml`:
+
+```toml
+[llm]
+num_retries = 4
+retry_min_wait = 5
+retry_max_wait = 30
+retry_multiplier = 2
+```

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/local-llms.md

@@ -0,0 +1,192 @@
+# Local LLM with Ollama
+
+:::warning
+When using a Local LLM, OpenHands may have limited functionality.
+:::
+
+Ensure that you have the Ollama server up and running.
+For detailed startup instructions, refer to [here](https://github.com/ollama/ollama).
+
+This guide assumes you've started ollama with `ollama serve`. If you're running ollama differently (e.g. inside docker), the instructions might need to be modified. Please note that if you're running WSL the default ollama configuration blocks requests from docker containers. See [here](#configuring-ollama-service-wsl-en).
+
+## Pull Models
+
+Ollama model names can be found [here](https://ollama.com/library). For a small example, you can use
+the `codellama:7b` model. Bigger models will generally perform better.
+
+```bash
+ollama pull codellama:7b
+```
+
+you can check which models you have downloaded like this:
+
+```bash
+~$ ollama list
+NAME                            ID              SIZE    MODIFIED
+codellama:7b                    8fdf8f752f6e    3.8 GB  6 weeks ago
+mistral:7b-instruct-v0.2-q4_K_M eb14864c7427    4.4 GB  2 weeks ago
+starcoder2:latest               f67ae0f64584    1.7 GB  19 hours ago
+```
+
+## Run OpenHands with Docker
+
+### Start OpenHands
+Use the instructions [here](../getting-started) to start OpenHands using Docker.
+But when running `docker run`, you'll need to add a few more arguments:
+
+```bash
+docker run # ...
+    --add-host host.docker.internal:host-gateway \
+    -e LLM_OLLAMA_BASE_URL="http://host.docker.internal:11434" \
+    # ...
+```
+
+LLM_OLLAMA_BASE_URL is optional. If you set it, it will be used to show
+the available installed models in the UI.
+
+
+### Configure the Web Application
+
+When running `openhands`, you'll need to set the following in the OpenHands UI through the Settings:
+- the model to "ollama/<model-name>"
+- the base url to `http://host.docker.internal:11434`
+- the API key is optional, you can use any string, such as `ollama`.
+
+
+## Run OpenHands in Development Mode
+
+### Build from Source
+
+Use the instructions in [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md) to build OpenHands.
+Make sure `config.toml` is there by running `make setup-config` which will create one for you. In `config.toml`, enter the followings:
+
+```
+[core]
+workspace_base="./workspace"
+
+[llm]
+embedding_model="local"
+ollama_base_url="http://localhost:11434"
+
+```
+
+Done! Now you can start OpenHands by: `make run`. You now should be able to connect to `http://localhost:3000/`
+
+### Configure the Web Application
+
+In the OpenHands UI, click on the Settings wheel in the bottom-left corner.
+Then in the `Model` input, enter `ollama/codellama:7b`, or the name of the model you pulled earlier.
+If it doesn’t show up in the dropdown, enable `Advanced Settings` and type it in. Please note: you need the model name as listed by `ollama list`, with the prefix `ollama/`.
+
+In the API Key field, enter `ollama` or any value, since you don't need a particular key.
+
+In the Base URL field, enter `http://localhost:11434`.
+
+And now you're ready to go!
+
+## Configuring the ollama service (WSL) {#configuring-ollama-service-wsl-en}
+
+The default configuration for ollama in WSL only serves localhost. This means you can't reach it from a docker container. eg. it wont work with OpenHands. First let's test that ollama is running correctly.
+
+```bash
+ollama list # get list of installed models
+curl http://localhost:11434/api/generate -d '{"model":"[NAME]","prompt":"hi"}'
+#ex. curl http://localhost:11434/api/generate -d '{"model":"codellama:7b","prompt":"hi"}'
+#ex. curl http://localhost:11434/api/generate -d '{"model":"codellama","prompt":"hi"}' #the tag is optional if there is only one
+```
+
+Once that is done, test that it allows "outside" requests, like those from inside a docker container.
+
+```bash
+docker ps # get list of running docker containers, for most accurate test choose the OpenHands sandbox container.
+docker exec [CONTAINER ID] curl http://host.docker.internal:11434/api/generate -d '{"model":"[NAME]","prompt":"hi"}'
+#ex. docker exec cd9cc82f7a11 curl http://host.docker.internal:11434/api/generate -d '{"model":"codellama","prompt":"hi"}'
+```
+
+## Fixing it
+
+Now let's make it work. Edit /etc/systemd/system/ollama.service with sudo privileges. (Path may vary depending on linux flavor)
+
+```bash
+sudo vi /etc/systemd/system/ollama.service
+```
+
+or
+
+```bash
+sudo nano /etc/systemd/system/ollama.service
+```
+
+In the [Service] bracket add these lines
+
+```
+Environment="OLLAMA_HOST=0.0.0.0:11434"
+Environment="OLLAMA_ORIGINS=*"
+```
+
+Then save, reload the configuration and restart the service.
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl restart ollama
+```
+
+Finally test that ollama is accessible from within the container
+
+```bash
+ollama list # get list of installed models
+docker ps # get list of running docker containers, for most accurate test choose the OpenHands sandbox container.
+docker exec [CONTAINER ID] curl http://host.docker.internal:11434/api/generate -d '{"model":"[NAME]","prompt":"hi"}'
+```
+
+
+# Local LLM with LM Studio
+
+Steps to set up LM Studio:
+1. Open LM Studio
+2. Go to the Local Server tab.
+3. Click the "Start Server" button.
+4. Select the model you want to use from the dropdown.
+
+
+Set the following configs:
+```bash
+LLM_MODEL="openai/lmstudio"
+LLM_BASE_URL="http://localhost:1234/v1"
+CUSTOM_LLM_PROVIDER="openai"
+```
+
+### Docker
+
+```bash
+docker run # ...
+    -e LLM_MODEL="openai/lmstudio" \
+    -e LLM_BASE_URL="http://host.docker.internal:1234/v1" \
+    -e CUSTOM_LLM_PROVIDER="openai" \
+    # ...
+```
+
+You should now be able to connect to `http://localhost:3000/`
+
+In the development environment, you can set the following configs in the `config.toml` file:
+
+```
+[core]
+workspace_base="./workspace"
+
+[llm]
+model="openai/lmstudio"
+base_url="http://localhost:1234/v1"
+custom_llm_provider="openai"
+```
+
+Done! Now you can start OpenHands by: `make run` without Docker. You now should be able to connect to `http://localhost:3000/`
+
+# Note
+
+For WSL, run the following commands in cmd to set up the networking mode to mirrored:
+
+```
+python -c  "print('[wsl2]\nnetworkingMode=mirrored',file=open(r'%UserProfile%\.wslconfig','w'))"
+wsl --shutdown
+```

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/openai-llms.md

@@ -0,0 +1,25 @@
+# OpenAI
+
+O OpenHands usa o LiteLLM para fazer chamadas para os modelos de chat da OpenAI. Você pode encontrar a documentação deles sobre como usar a OpenAI como provedor [aqui](https://docs.litellm.ai/docs/providers/openai).
+
+## Configuração
+
+Ao executar o OpenHands, você precisará definir o seguinte na interface do usuário do OpenHands através das Configurações:
+* `LLM Provider` para `OpenAI`
+* `LLM Model` para o modelo que você usará.
+[Visite aqui para ver uma lista completa dos modelos da OpenAI que o LiteLLM suporta.](https://docs.litellm.ai/docs/providers/openai#openai-chat-completion-models)
+Se o modelo não estiver na lista, ative as opções `Advanced` e insira-o em `Custom Model` (por exemplo, openai/<model-name> como `openai/gpt-4o`).
+* `API Key` para a sua chave de API da OpenAI. Para encontrar ou criar sua chave de API do projeto OpenAI, [veja aqui](https://platform.openai.com/api-keys).
+
+## Usando Endpoints Compatíveis com OpenAI
+
+Assim como para as conclusões de chat da OpenAI, usamos o LiteLLM para endpoints compatíveis com OpenAI. Você pode encontrar a documentação completa deles sobre este tópico [aqui](https://docs.litellm.ai/docs/providers/openai_compatible).
+
+## Usando um Proxy OpenAI
+
+Se você estiver usando um proxy OpenAI, na interface do usuário do OpenHands através das Configurações:
+1. Ative as opções `Advanced`
+2. Defina o seguinte:
+   - `Custom Model` para openai/<model-name> (por exemplo, `openai/gpt-4o` ou openai/<proxy-prefix>/<model-name>)
+   - `Base URL` para a URL do seu proxy OpenAI
+   - `API Key` para a sua chave de API da OpenAI

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/llms/openrouter.md

@@ -0,0 +1,14 @@
+Here is the translated content in Brazilian Portuguese:
+
+# OpenRouter
+
+O OpenHands usa o LiteLLM para fazer chamadas para modelos de chat no OpenRouter. Você pode encontrar a documentação deles sobre como usar o OpenRouter como provedor [aqui](https://docs.litellm.ai/docs/providers/openrouter).
+
+## Configuração
+
+Ao executar o OpenHands, você precisará definir o seguinte na interface do usuário do OpenHands através das Configurações:
+* `LLM Provider` para `OpenRouter`
+* `LLM Model` para o modelo que você usará.
+[Visite aqui para ver uma lista completa de modelos do OpenRouter](https://openrouter.ai/models).
+Se o modelo não estiver na lista, ative as opções `Advanced` e insira-o em `Custom Model` (por exemplo, openrouter/<model-name> como `openrouter/anthropic/claude-3.5-sonnet`).
+* `API Key` para a sua chave de API do OpenRouter.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/prompting/microagents-overview.md

@@ -0,0 +1,33 @@
+# Visão Geral dos Microagentes
+
+Os microagentes são prompts especializados que aprimoram o OpenHands com conhecimento específico de domínio, contexto específico de repositório e fluxos de trabalho específicos de tarefas. Eles ajudam fornecendo orientação especializada, automatizando tarefas comuns e garantindo práticas consistentes em todos os projetos.
+
+## Tipos de Microagentes
+
+Atualmente, o OpenHands suporta os seguintes tipos de microagentes:
+
+* [Microagentes de Repositório](./microagents-repo): Contexto e diretrizes específicas do repositório para o OpenHands.
+* [Microagentes Públicos](./microagents-public): Diretrizes gerais acionadas por palavras-chave para todos os usuários do OpenHands.
+
+Quando o OpenHands trabalha com um repositório, ele:
+
+1. Carrega instruções específicas do repositório de `.openhands/microagents/`, se presentes no repositório.
+2. Carrega diretrizes gerais acionadas por palavras-chave nas conversas.
+Veja os [Microagentes Públicos](https://github.com/All-Hands-AI/OpenHands/tree/main/microagents/knowledge) atuais.
+
+## Formato do Microagente
+
+Todos os microagentes usam arquivos markdown com frontmatter YAML que possuem instruções especiais para ajudar o OpenHands a realizar tarefas:
+```
+---
+name: <Nome do microagente>
+type: <Tipo do MicroAgent>
+version: <Versão do MicroAgent>
+agent: <O tipo de agente (normalmente CodeActAgent)>
+triggers:
+- <Palavras-chave opcionais que acionam o microagente. Se os gatilhos forem removidos, ele sempre será incluído>
+---
+
+<Markdown com quaisquer diretrizes especiais, instruções e prompts que o OpenHands deve seguir.
+Confira a documentação específica para cada microagente sobre as melhores práticas para obter mais informações.>
+```

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/prompting/microagents-public.md

@@ -0,0 +1,153 @@
+# Microagentes Públicos
+
+## Visão Geral
+
+Microagentes públicos são diretrizes especializadas acionadas por palavras-chave para todos os usuários do OpenHands.
+Eles são definidos em arquivos markdown no diretório
+[`microagents/knowledge/`](https://github.com/All-Hands-AI/OpenHands/tree/main/microagents/knowledge).
+
+Microagentes públicos:
+- Monitoram comandos recebidos em busca de suas palavras-chave de acionamento.
+- São ativados quando os gatilhos relevantes são detectados.
+- Aplicam seus conhecimentos e capacidades especializados.
+- Seguem suas diretrizes e restrições específicas.
+
+## Microagentes Públicos Atuais
+
+Para mais informações sobre microagentes específicos, consulte seus arquivos de documentação individuais no
+diretório [`microagents/knowledge/`](https://github.com/All-Hands-AI/OpenHands/tree/main/microagents/knowledge/).
+
+### Agente GitHub
+**Arquivo**: `github.md`
+**Gatilhos**: `github`, `git`
+
+O agente GitHub é especializado em interações com a API do GitHub e gerenciamento de repositórios. Ele:
+- Tem acesso a um `GITHUB_TOKEN` para autenticação na API.
+- Segue diretrizes rígidas para interações com repositórios.
+- Lida com gerenciamento de branches e pull requests.
+- Usa a API do GitHub em vez de interações com navegador web.
+
+Principais recursos:
+- Proteção de branch (impede push direto para main/master)
+- Criação automatizada de PR
+- Gerenciamento de configuração do Git
+- Abordagem API-first para operações do GitHub
+
+Exemplo de Uso:
+
+```bash
+git checkout -b feature-branch
+git commit -m "Add new feature"
+git push origin feature-branch
+```
+
+### Agente NPM
+**Arquivo**: `npm.md`
+**Gatilhos**: `npm`
+
+Especializado em lidar com gerenciamento de pacotes npm com foco específico em:
+- Operações shell não interativas.
+- Tratamento automatizado de confirmação usando o comando Unix 'yes'.
+- Automação de instalação de pacotes.
+
+Exemplo de Uso:
+
+```bash
+yes | npm install package-name
+```
+
+## Contribuindo com um Microagente Público
+
+Você pode criar seus próprios microagentes públicos adicionando novos arquivos markdown ao
+diretório [`microagents/knowledge/`](https://github.com/All-Hands-AI/OpenHands/tree/main/microagents/knowledge/).
+
+### Melhores Práticas para Microagentes Públicos
+
+- **Escopo Claro**: Mantenha o microagente focado em um domínio ou tarefa específica.
+- **Instruções Explícitas**: Forneça diretrizes claras e inequívocas.
+- **Exemplos Úteis**: Inclua exemplos práticos de casos de uso comuns.
+- **Segurança em Primeiro Lugar**: Inclua avisos e restrições necessárias.
+- **Consciência de Integração**: Considere como o microagente interage com outros componentes.
+
+### Etapas para Contribuir com um Microagente Público
+
+#### 1. Planeje o Microagente Público
+
+Antes de criar um microagente público, considere:
+- Qual problema ou caso de uso específico ele abordará?
+- Quais capacidades ou conhecimentos únicos ele deve ter?
+- Quais palavras-chave fazem sentido para ativá-lo?
+- Quais restrições ou diretrizes ele deve seguir?
+
+#### 2. Crie o Arquivo
+
+Crie um novo arquivo markdown em [`microagents/knowledge/`](https://github.com/All-Hands-AI/OpenHands/tree/main/microagents/knowledge/)
+com um nome descritivo (por exemplo, `docker.md` para um agente focado em Docker).
+
+Atualize o arquivo com o frontmatter necessário [de acordo com o formato exigido](./microagents-overview#microagent-format)
+e as diretrizes especializadas necessárias, seguindo as [melhores práticas acima](#melhores-práticas-para-microagentes-públicos).
+
+#### 3. Testando o Microagente Público
+
+- Teste o agente com vários prompts.
+- Verifique se as palavras-chave acionam o agente corretamente.
+- Certifique-se de que as instruções estão claras e abrangentes.
+- Verifique possíveis conflitos com agentes existentes.
+
+#### 4. Processo de Envio
+
+Envie um pull request com:
+- O novo arquivo do microagente.
+- Documentação atualizada, se necessário.
+- Descrição do propósito e das capacidades do agente.
+
+### Exemplo de Implementação de Microagente Público
+
+Aqui está um modelo para um novo microagente:
+
+```markdown
+---
+name: docker
+agent: CodeActAgent
+triggers:
+- docker
+- container
+---
+
+Você é responsável pelo gerenciamento de contêineres Docker e criação de Dockerfile.
+
+Principais responsabilidades:
+1. Criar e modificar Dockerfiles
+2. Gerenciar o ciclo de vida do contêiner
+3. Lidar com configurações do Docker Compose
+
+Diretrizes:
+- Sempre use imagens base oficiais quando possível
+- Inclua considerações de segurança necessárias
+- Siga as melhores práticas do Docker para otimização de camadas
+
+Exemplos:
+1. Criando um Dockerfile:
+   FROM node:18-alpine
+   WORKDIR /app
+   COPY package*.json ./
+   RUN npm install
+   COPY . .
+   CMD ["npm", "start"]
+
+2. Uso do Docker Compose:
+   version: '3'
+   services:
+     web:
+       build: .
+       ports:
+         - "3000:3000"
+
+Lembre-se de:
+- Validar a sintaxe do Dockerfile
+- Verificar vulnerabilidades de segurança
+- Otimizar para tempo de build e tamanho da imagem
+```
+
+Veja os [microagentes públicos atuais](https://github.com/All-Hands-AI/OpenHands/tree/main/microagents/knowledge) para
+mais exemplos.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/prompting/microagents-repo.md

@@ -0,0 +1,68 @@
+# Microagentes de Repositório
+
+## Visão Geral
+
+O OpenHands pode ser personalizado para trabalhar de forma mais eficaz com repositórios específicos, fornecendo contexto
+e diretrizes específicas do repositório. Esta seção explica como otimizar o OpenHands para o seu projeto.
+
+## Criando um Micro-Agente de Repositório
+
+Você pode personalizar o comportamento do OpenHands para o seu repositório criando um diretório `.openhands/microagents/` na raiz do seu repositório.
+No mínimo, ele deve conter o arquivo
+`.openhands/microagents/repo.md`, que inclui instruções que serão
+fornecidas ao agente toda vez que ele trabalhar com este repositório.
+
+### Melhores Práticas para Microagentes de Repositório
+
+- **Mantenha as Instruções Atualizadas**: Atualize regularmente o seu diretório `.openhands/microagents/` à medida que o seu projeto evolui.
+- **Seja Específico**: Inclua caminhos, padrões e requisitos específicos exclusivos do seu projeto.
+- **Documente as Dependências**: Liste todas as ferramentas e dependências necessárias para o desenvolvimento.
+- **Inclua Exemplos**: Forneça exemplos de bons padrões de código do seu projeto.
+- **Especifique Convenções**: Documente convenções de nomenclatura, organização de arquivos e preferências de estilo de código.
+
+### Etapas para Criar um Microagente de Repositório
+
+#### 1. Planeje o Microagente de Repositório
+Ao criar um micro-agente específico para um repositório, sugerimos incluir as seguintes informações:
+- **Visão Geral do Repositório**: Uma breve descrição do propósito e arquitetura do seu projeto.
+- **Estrutura de Diretórios**: Diretórios-chave e seus propósitos.
+- **Diretrizes de Desenvolvimento**: Padrões e práticas de codificação específicas do projeto.
+- **Requisitos de Teste**: Como executar testes e quais tipos de testes são necessários.
+- **Instruções de Configuração**: Etapas necessárias para construir e executar o projeto.
+
+#### 2. Crie o Arquivo
+
+Crie um arquivo em seu repositório em `.openhands/microagents/` (Exemplo: `.openhands/microagents/repo.md`)
+
+Atualize o arquivo com o frontmatter necessário [de acordo com o formato exigido](./microagents-overview#microagent-format)
+e as diretrizes especializadas necessárias para o seu repositório.
+
+### Exemplo de Microagente de Repositório
+
+```
+---
+name: repo
+type: repo
+agent: CodeActAgent
+---
+
+Repository: MeuProjeto
+Description: Uma aplicação web para gerenciamento de tarefas
+
+Directory Structure:
+- src/: Código principal da aplicação
+- tests/: Arquivos de teste
+- docs/: Documentação
+
+Setup:
+- Execute `npm install` para instalar as dependências
+- Use `npm run dev` para desenvolvimento
+- Execute `npm test` para testes
+
+Guidelines:
+- Siga a configuração do ESLint
+- Escreva testes para todos os novos recursos
+- Use TypeScript para novo código
+
+Se adicionar um novo componente em src/components, sempre adicione testes unitários apropriados em tests/components/.
+```

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/prompting/prompting-best-practices.md

@@ -0,0 +1,37 @@
+# Melhores Práticas de Prompt
+
+Ao trabalhar com o desenvolvedor de software OpenHands AI, é crucial fornecer prompts claros e eficazes. Este guia descreve as melhores práticas para criar prompts que produzirão as respostas mais precisas e úteis.
+
+## Características de Bons Prompts
+
+Bons prompts são:
+
+- **Concretos**: Eles explicam exatamente qual funcionalidade deve ser adicionada ou qual erro precisa ser corrigido.
+- **Específicos de localização**: Se conhecido, eles explicam os locais na base de código que devem ser modificados.
+- **Escopo apropriado**: Eles devem ter o tamanho de uma única funcionalidade, normalmente não excedendo 100 linhas de código.
+
+## Exemplos
+
+### Exemplos de Bons Prompts
+
+- "Adicione uma função `calculate_average` em `utils/math_operations.py` que recebe uma lista de números como entrada e retorna sua média."
+- "Corrija o TypeError em `frontend/src/components/UserProfile.tsx` ocorrendo na linha 42. O erro sugere que estamos tentando acessar uma propriedade de undefined."
+- "Implemente a validação de entrada para o campo de e-mail no formulário de registro. Atualize `frontend/src/components/RegistrationForm.tsx` para verificar se o e-mail está em um formato válido antes do envio."
+
+### Exemplos de Maus Prompts
+
+- "Torne o código melhor." (Muito vago, não concreto)
+- "Reescreva todo o backend para usar um framework diferente." (Escopo não apropriado)
+- "Há um bug em algum lugar na autenticação do usuário. Você pode encontrá-lo e corrigi-lo?" (Falta especificidade e informações de localização)
+
+## Dicas para Prompts Eficazes
+
+- Seja o mais específico possível sobre o resultado desejado ou o problema a ser resolvido.
+- Forneça contexto, incluindo caminhos de arquivo relevantes e números de linha, se disponíveis.
+- Divida tarefas grandes em prompts menores e gerenciáveis.
+- Inclua quaisquer mensagens de erro ou logs relevantes.
+- Especifique a linguagem de programação ou framework se não for óbvio a partir do contexto.
+
+Lembre-se, quanto mais preciso e informativo for o seu prompt, melhor a IA poderá ajudá-lo a desenvolver ou modificar o software OpenHands.
+
+Veja [Começando com o OpenHands](../getting-started) para mais exemplos de prompts úteis.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/runtimes.md

@@ -0,0 +1,165 @@
+# Configuração de Runtime
+
+Um Runtime é um ambiente onde o agente OpenHands pode editar arquivos e executar comandos.
+
+Por padrão, o OpenHands usa um runtime baseado em Docker, executando no seu computador local. Isso significa que você só precisa pagar pelo LLM que está usando, e seu código é enviado apenas para o LLM.
+
+Também suportamos runtimes "remotos", que são tipicamente gerenciados por terceiros. Eles podem tornar a configuração um pouco mais simples e escalável, especialmente se você estiver executando muitas conversas do OpenHands em paralelo (por exemplo, para fazer avaliação).
+
+Além disso, fornecemos um runtime "local" que é executado diretamente na sua máquina sem o Docker, o que pode ser útil em ambientes controlados como pipelines de CI.
+
+## Runtime Docker
+Este é o Runtime padrão que é usado quando você inicia o OpenHands. Você pode notar algumas flags sendo passadas para o `docker run` que tornam isso possível:
+
+```
+docker run # ...
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    # ...
+```
+
+O `SANDBOX_RUNTIME_CONTAINER_IMAGE` do nikolaik é uma imagem de runtime pré-construída que contém nosso servidor Runtime, bem como algumas utilidades básicas para Python e NodeJS. Você também pode [construir sua própria imagem de runtime](how-to/custom-sandbox-guide).
+
+### Conectando ao seu sistema de arquivos
+Um recurso útil aqui é a capacidade de se conectar ao seu sistema de arquivos local. Para montar seu sistema de arquivos no runtime:
+1. Defina `WORKSPACE_BASE`:
+
+    ```bash
+    export WORKSPACE_BASE=/caminho/para/seu/codigo
+
+    # Exemplo no Linux e Mac
+    # export WORKSPACE_BASE=$HOME/OpenHands
+    # Definirá $WORKSPACE_BASE como /home/<username>/OpenHands
+    #
+    # Exemplo no WSL no Windows
+    # export WORKSPACE_BASE=/mnt/c/dev/OpenHands
+    # Definirá $WORKSPACE_BASE como C:\dev\OpenHands
+    ```
+2. Adicione as seguintes opções ao comando `docker run`:
+
+    ```bash
+    docker run # ...
+        -e SANDBOX_USER_ID=$(id -u) \
+        -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
+        -v $WORKSPACE_BASE:/opt/workspace_base \
+        # ...
+    ```
+
+Tenha cuidado! Não há nada impedindo o agente OpenHands de excluir ou modificar quaisquer arquivos que estejam montados em seu workspace.
+
+Essa configuração pode causar alguns problemas com permissões de arquivo (daí a variável `SANDBOX_USER_ID`), mas parece funcionar bem na maioria dos sistemas.
+
+## OpenHands Remote Runtime
+
+O OpenHands Remote Runtime está atualmente em beta (leia [aqui](https://runtime.all-hands.dev/) para mais detalhes), ele permite que você inicie runtimes em paralelo na nuvem. Preencha [este formulário](https://docs.google.com/forms/d/e/1FAIpQLSckVz_JFwg2_mOxNZjCtr7aoBFI2Mwdan3f75J_TrdMS1JV2g/viewform) para se inscrever se quiser experimentar isso!
+
+NOTA: Este runtime é projetado especificamente apenas para fins de avaliação de agentes por meio do [harness de avaliação do OpenHands](https://github.com/All-Hands-AI/OpenHands/tree/main/evaluation). Ele não deve ser usado para iniciar aplicativos OpenHands em produção.
+
+## Runtime Modal
+Nossos parceiros na [Modal](https://modal.com/) também forneceram um runtime para o OpenHands.
+
+Para usar o Runtime Modal, crie uma conta e, em seguida, [crie uma chave de API.](https://modal.com/settings)
+
+Você precisará definir as seguintes variáveis de ambiente ao iniciar o OpenHands:
+```bash
+docker run # ...
+    -e RUNTIME=modal \
+    -e MODAL_API_TOKEN_ID="seu-id" \
+    -e MODAL_API_TOKEN_SECRET="seu-segredo" \
+```
+
+## Runtime Daytona
+
+Outra opção é usar o [Daytona](https://www.daytona.io/) como provedor de runtime:
+
+### Passo 1: Recupere sua chave de API do Daytona
+1. Visite o [Painel do Daytona](https://app.daytona.io/dashboard/keys).
+2. Clique em **"Create Key"**.
+3. Digite um nome para sua chave e confirme a criação.
+4. Depois que a chave for gerada, copie-a.
+
+### Passo 2: Defina sua chave de API como uma variável de ambiente
+Execute o seguinte comando no seu terminal, substituindo `<sua-chave-de-api>` pela chave real que você copiou:
+```bash
+export DAYTONA_API_KEY="<sua-chave-de-api>"
+```
+
+Esta etapa garante que o OpenHands possa se autenticar na plataforma Daytona quando for executado.
+
+### Passo 3: Execute o OpenHands localmente usando o Docker
+Para iniciar a versão mais recente do OpenHands em sua máquina, execute o seguinte comando no seu terminal:
+```bash
+bash -i <(curl -sL https://get.daytona.io/openhands)
+```
+
+#### O que este comando faz:
+- Baixa o script de lançamento mais recente do OpenHands.
+- Executa o script em uma sessão interativa do Bash.
+- Automaticamente baixa e executa o contêiner do OpenHands usando o Docker.
+
+Uma vez executado, o OpenHands deve estar sendo executado localmente e pronto para uso.
+
+Para mais detalhes e inicialização manual, veja o [README.md](https://github.com/All-Hands-AI/OpenHands/blob/main/openhands/runtime/impl/daytona/README.md) completo.
+
+## Runtime Local
+
+O Runtime Local permite que o agente OpenHands execute ações diretamente em sua máquina local sem usar o Docker. Este runtime é destinado principalmente para ambientes controlados, como pipelines de CI ou cenários de teste onde o Docker não está disponível.
+
+:::caution
+**Aviso de segurança**: O Runtime Local é executado sem nenhum isolamento de sandbox. O agente pode acessar e modificar diretamente os arquivos em sua máquina. Use este runtime apenas em ambientes controlados ou quando você entender completamente as implicações de segurança.
+:::
+
+### Pré-requisitos
+
+Antes de usar o Runtime Local, certifique-se de ter as seguintes dependências instaladas:
+
+1. Você seguiu as [instruções de configuração de desenvolvimento](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
+2. O tmux está disponível em seu sistema.
+
+### Configuração
+
+Para usar o Runtime Local, além das configurações necessárias como o modelo, chave de API, você precisará definir as seguintes opções por meio de variáveis de ambiente ou do [arquivo config.toml](https://github.com/All-Hands-AI/OpenHands/blob/main/config.template.toml) ao iniciar o OpenHands:
+
+- Via variáveis de ambiente:
+
+```bash
+# Obrigatório
+export RUNTIME=local
+
+# Opcional, mas recomendado
+export WORKSPACE_BASE=/caminho/para/seu/workspace
+```
+
+- Via `config.toml`:
+
+```toml
+[core]
+runtime = "local"
+workspace_base = "/caminho/para/seu/workspace"
+```
+
+Se `WORKSPACE_BASE` não for definido, o runtime criará um diretório temporário para o agente trabalhar.
+
+### Exemplo de uso
+
+Aqui está um exemplo de como iniciar o OpenHands com o Runtime Local no Modo Headless:
+
+```bash
+# Define o tipo de runtime como local
+export RUNTIME=local
+
+# Opcionalmente, define um diretório de workspace
+export WORKSPACE_BASE=/caminho/para/seu/projeto
+
+# Inicia o OpenHands
+poetry run python -m openhands.core.main -t "escreva um script bash que imprima oi"
+```
+
+### Casos de uso
+
+O Runtime Local é particularmente útil para:
+
+- Pipelines de CI/CD onde o Docker não está disponível.
+- Testes e desenvolvimento do próprio OpenHands.
+- Ambientes onde o uso de contêineres é restrito.
+- Cenários onde o acesso direto ao sistema de arquivos é necessário.

docs/i18n/pt-BR/docusaurus-plugin-content-docs/current/usage/troubleshooting/troubleshooting.md

@@ -0,0 +1,48 @@
+# 🚧 Solução de Problemas
+
+:::tip
+O OpenHands só suporta Windows via WSL. Certifique-se de executar todos os comandos dentro do seu terminal WSL.
+:::
+
+### Falha ao iniciar o cliente docker
+
+**Descrição**
+
+Ao executar o OpenHands, o seguinte erro é visto:
+
+```
+Launch docker client failed. Please make sure you have installed docker and started docker desktop/daemon.
+```
+
+**Resolução**
+
+Tente estes passos em ordem:
+
+- Confirme que o `docker` está em execução no seu sistema. Você deve ser capaz de executar `docker ps` no terminal com sucesso.
+- Se estiver usando o Docker Desktop, certifique-se de que `Settings > Advanced > Allow the default Docker socket to be used` esteja habilitado.
+- Dependendo da sua configuração, você pode precisar habilitar `Settings > Resources > Network > Enable host networking` no Docker Desktop.
+- Reinstale o Docker Desktop.
+
+---
+
+# Problemas Específicos ao Ambiente de Desenvolvimento
+
+### Erro ao construir a imagem docker do runtime
+
+**Descrição**
+
+Tentativas de iniciar uma nova sessão falham e erros com termos como os seguintes aparecem nos logs:
+
+```
+debian-security bookworm-security
+InRelease At least one invalid signature was encountered.
+```
+
+Isso parece acontecer quando o hash de uma biblioteca externa existente muda e sua instância local do docker tem uma versão anterior em cache. Para contornar isso, tente o seguinte:
+
+- Pare quaisquer contêineres onde o nome tenha o prefixo `openhands-runtime-`:
+  `docker ps --filter name=openhands-runtime- --filter status=running -aq | xargs docker stop`
+- Remova quaisquer contêineres onde o nome tenha o prefixo `openhands-runtime-`:
+  `docker rmi $(docker images --filter name=openhands-runtime- -q --no-trunc)`
+- Pare e remova quaisquer contêineres / imagens onde o nome tenha o prefixo `openhands-runtime-`
+- Limpe contêineres / imagens: `docker container prune -f && docker image prune -f`

docs/i18n/zh-Hans/code.json

@@ -402,5 +402,26 @@
   "theme.unlistedContent.message": {
     "message": "此页面未列出。搜索引擎不会对其索引，只有拥有直接链接的用户才能访问。",
     "description": "The unlisted content banner message"
+  },
+  "Use AI to tackle the toil in your backlog. Our agents have all the same tools as a human developer: they can modify code, run commands, browse the web, call APIs, and yes-even copy code snippets from StackOverflow.": {
+    "message": "使用AI处理您积压的工作。我们的代理拥有与人类开发者相同的工具：它们可以修改代码、运行命令、浏览网页、调用API，甚至从StackOverflow复制代码片段。"
+  },
+  "Get started with OpenHands.": {
+    "message": "开始使用OpenHands"
+  },
+  "Most Popular Links": {
+    "message": "热门链接"
+  },
+  "Customizing OpenHands to a repository": {
+    "message": "为仓库定制OpenHands"
+  },
+  "Integrating OpenHands with Github": {
+    "message": "将OpenHands与Github集成"
+  },
+  "Recommended models to use": {
+    "message": "推荐使用的模型"
+  },
+  "Connecting OpenHands to your filesystem": {
+    "message": "将OpenHands连接到您的文件系统"
   }
 }

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/architecture/runtime.md

@@ -1,8 +1,8 @@
 以下是翻译后的内容:
 
-# 📦 EventStream 运行时
+# 📦 Docker 运行时
 
-OpenHands EventStream 运行时是实现 AI 代理操作安全灵活执行的核心组件。
+OpenHands Docker 运行时是实现 AI 代理操作安全灵活执行的核心组件。
 它使用 Docker 创建一个沙盒环境,可以安全地运行任意代码而不会危及主机系统。
 
 ## 为什么我们需要沙盒运行时?

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/configuration-options.md

@@ -10,41 +10,39 @@
 
 # 目录
 
-1. [核心配置](#核心配置)
+1. [核心配置](#core-configuration)
    - [API Keys](#api-keys)
-   - [工作区](#工作区)
-   - [调试和日志记录](#调试和日志记录)
-   - [会话管理](#会话管理)
-   - [轨迹](#轨迹)
-   - [文件存储](#文件存储)
-   - [任务管理](#任务管理)
-   - [沙箱配置](#沙箱配置)
-   - [其他](#其他)
-2. [LLM 配置](#llm-配置)
-   - [AWS 凭证](#aws-凭证)
-   - [API 配置](#api-配置)
-   - [自定义 LLM Provider](#自定义-llm-provider)
+   - [工作区](#workspace)
+   - [调试和日志记录](#debugging-and-logging)
+   - [轨迹](#trajectories)
+   - [文件存储](#file-store)
+   - [任务管理](#task-management)
+   - [沙箱配置](#sandbox-configuration)
+   - [其他](#miscellaneous)
+2. [LLM 配置](#llm-configuration)
+   - [AWS 凭证](#aws-credentials)
+   - [API 配置](#api-configuration)
+   - [自定义 LLM Provider](#custom-llm-provider)
    - [Embeddings](#embeddings)
-   - [消息处理](#消息处理)
-   - [模型选择](#模型选择)
-   - [重试](#重试)
-   - [高级选项](#高级选项)
-3. [Agent 配置](#agent-配置)
-   - [Microagent 配置](#microagent-配置)
-   - [内存配置](#内存配置)
-   - [LLM 配置](#llm-配置-2)
-   - [ActionSpace 配置](#actionspace-配置)
-   - [Microagent 使用](#microagent-使用)
-4. [沙箱配置](#沙箱配置-2)
-   - [执行](#执行)
-   - [容器镜像](#容器镜像)
-   - [网络](#网络)
-   - [Linting 和插件](#linting-和插件)
-   - [依赖和环境](#依赖和环境)
-   - [评估](#评估)
-5. [安全配置](#安全配置)
-   - [确认模式](#确认模式)
-   - [安全分析器](#安全分析器)
+   - [消息处理](#message-handling)
+   - [模型选择](#model-selection)
+   - [重试](#retrying)
+   - [高级选项](#advanced-options)
+3. [Agent 配置](#agent-configuration)
+   - [内存配置](#memory-configuration)
+   - [LLM 配置](#llm-configuration-1)
+   - [ActionSpace 配置](#actionspace-configuration)
+   - [Microagent 使用](#microagent-usage)
+4. [沙箱配置](#sandbox-configuration-1)
+   - [执行](#execution)
+   - [容器镜像](#container-image)
+   - [网络](#networking)
+   - [Linting 和插件](#linting-and-plugins)
+   - [依赖和环境](#dependencies-and-environment)
+   - [评估](#evaluation)
+5. [安全配置](#security-configuration)
+   - [确认模式](#confirmation-mode)
+   - [安全分析器](#security-analyzer)
 
 ---
 
@@ -162,7 +160,7 @@
 
 - `runtime`
   - 类型: `str`
-  - 默认值: `"eventstream"`
+  - 默认值: `"docker"`
   - 描述: 运行时环境
 
 - `default_agent`
@@ -328,12 +326,6 @@ LLM(大语言模型)配置选项在 `config.toml` 文件的 `[llm]` 部分中定
 
 Agent 配置选项在 `config.toml` 文件的 `[agent]` 和 `[agent.<agent_name>]` 部分中定义。
 
-**Microagent 配置**
-- `micro_agent_name`
-  - 类型: `str`
-  - 默认值: `""`
-  - 描述: 用于此 agent 的 micro agent 名称
-
 **内存配置**
 - `memory_enabled`
   - 类型: `bool`
@@ -373,7 +365,7 @@ Agent 配置选项在 `config.toml` 文件的 `[agent]` 和 `[agent.<agent_name>
   - 描述: 是否在 action space 中启用 Jupyter
 
 **Microagent 使用**
-- `use_microagents`
+- `enable_prompt_extensions`
   - 类型: `bool`
   - 默认值: `true`
   - 描述: 是否使用 microagents

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/custom_sandbox_guide.md

@@ -58,10 +58,11 @@ docker build -t custom_image .
 [core]
 workspace_base="./workspace"
 run_as_openhands=true
-sandbox_base_container_image="custom_image"
+[sandbox]
+base_container_image="custom_image"
 ```
 
-对于 `sandbox_base_container_image` 的值, 您可以选择以下任意一项：
+对于 `base_container_image` 的值, 您可以选择以下任意一项：
 1. 在上一步中您构建的自定义镜像的名称（例如，`“custom_image”`）
 2. 从 Docker Hub 拉取的镜像（例如，`“node:20”`，如果你需要一个预装 `Node.js` 的沙箱环境）
 
@@ -83,20 +84,17 @@ sandbox_base_container_image="custom_image"
 
 ### 错误：```useradd: UID 1000 is not unique```
 
-如果在控制台输出中看到此错误，说明 OpenHands 尝试在沙箱中以 UID 1000 创建 openhands 用户，但该 UID 已经被映像中的其他部分使用（不知何故）。要解决这个问题，请更改 config.toml 文件中的 sandbox_user_id 字段为不同的值：
+如果在控制台输出中看到此错误，说明 OpenHands 尝试在沙箱中以 UID 1000 创建 openhands 用户，但该 UID 已经被映像中的其他部分使用（不知何故）。要解决这个问题，请更改 config.toml 文件中的 user_id 字段为不同的值：
 
 ```
 [core]
 workspace_base="./workspace"
 run_as_openhands=true
-sandbox_base_container_image="custom_image"
-sandbox_user_id="1001"
+[sandbox]
+base_container_image="custom_image"
+user_id="1001"
 ```
 
 ### 端口使用错误
 
 如果您遇到端口被占用或不可用的错误提示，可以尝试先用`docker ps`命令列出所有运行中的 Docker 容器，然后使用`docker rm`命令删除相关容器，最后再重新执行```make run```命令。
-
-## 讨论
-
-对于其他问题或疑问，请加入 [Slack](https://join.slack.com/t/openhands-ai/shared_invite/zt-2wkh4pklz-w~h_DVDtEe9H5kyQlcNxVw) 或 [Discord](https://discord.gg/ESHStjSjD4) 提问！

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/how-to/cli-mode.md

@@ -50,7 +50,7 @@ LLM_API_KEY="sk_test_12345"
 ```bash
 docker run -it \
     --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e SANDBOX_USER_ID=$(id -u) \
     -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
     -e LLM_API_KEY=$LLM_API_KEY \
@@ -59,7 +59,7 @@ docker run -it \
     -v /var/run/docker.sock:/var/run/docker.sock \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app-$(date +%Y%m%d%H%M%S) \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20 \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29 \
     python -m openhands.core.cli
 ```
 

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/how-to/custom-sandbox-guide.md

@@ -42,12 +42,13 @@ docker build -t custom-image .
 
 ### 指定基础沙箱镜像
 
-在 OpenHands 目录中的 `config.toml` 文件中，将 `sandbox_base_container_image` 设置为你要使用的镜像。这可以是你已经拉取的镜像或你构建的镜像：
+在 OpenHands 目录中的 `config.toml` 文件中，将 `base_container_image` 设置为你要使用的镜像。这可以是你已经拉取的镜像或你构建的镜像：
 
 ```bash
 [core]
 ...
-sandbox_base_container_image="custom-image"
+[sandbox]
+base_container_image="custom-image"
 ```
 
 ### 运行

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/how-to/evaluation-harness.md

@@ -112,7 +112,7 @@ OpenHands 的主要入口点在 `openhands/core/main.py` 中。以下是它的
    def get_config(instance: pd.Series, metadata: EvalMetadata) -> AppConfig:
        config = AppConfig(
            default_agent=metadata.agent_class,
-           runtime='eventstream',
+           runtime='docker',
            max_iterations=metadata.max_iterations,
            sandbox=SandboxConfig(
                base_container_image='your_container_image',

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/how-to/headless-mode.md

@@ -47,7 +47,7 @@ LLM_API_KEY="sk_test_12345"
 ```bash
 docker run -it \
     --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e SANDBOX_USER_ID=$(id -u) \
     -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
     -e LLM_API_KEY=$LLM_API_KEY \
@@ -57,6 +57,6 @@ docker run -it \
     -v /var/run/docker.sock:/var/run/docker.sock \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app-$(date +%Y%m%d%H%M%S) \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20 \
+    docker.all-hands.dev/all-hands-ai/openhands:0.29 \
     python -m openhands.core.main -t "write a bash script that prints hi" --no-auto-continue
 ```

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/installation.mdx

@@ -11,16 +11,16 @@
 在 Docker 中运行 OpenHands 是最简单的方式。
 
 ```bash
-docker pull docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik
+docker pull docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik
 
 docker run -it --rm --pull=always \
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -e LOG_ALL_EVENTS=true \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
     --name openhands-app \
-    docker.all-hands.dev/all-hands-ai/openhands:0.20
+    docker.all-hands.dev/all-hands-ai/openhands:0.29
 ```
 
 你也可以在可脚本化的[无头模式](https://docs.all-hands.dev/modules/usage/how-to/headless-mode)下运行 OpenHands，作为[交互式 CLI](https://docs.all-hands.dev/modules/usage/how-to/cli-mode)，或使用 [OpenHands GitHub Action](https://docs.all-hands.dev/modules/usage/how-to/github-action)。

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/intro.mdx

@@ -42,7 +42,7 @@ OpenHands 是一个**自主 AI 软件工程师**，能够执行复杂的工程
   />
 </a>
 <br></br>
-<a href="https://join.slack.com/t/openhands-ai/shared_invite/zt-2wkh4pklz-w~h_DVDtEe9H5kyQlcNxVw">
+<a href="https://join.slack.com/t/openhands-ai/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw">
   <img
     src="https://img.shields.io/badge/Slack-Join%20Us-red?logo=slack&logoColor=white&style=for-the-badge"
     alt="Join our Slack community"

docs/i18n/zh-Hans/docusaurus-plugin-content-docs/current/usage/runtimes.md

@@ -11,7 +11,7 @@
 
 ```
 docker run # ...
-    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.20-nikolaik \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.29-nikolaik \
     -v /var/run/docker.sock:/var/run/docker.sock \
     # ...
 ```

docs/modules/usage/architecture/runtime.md

@@ -1,6 +1,6 @@
-# 📦 EventStream Runtime
+# 📦 Docker Runtime
 
-The OpenHands EventStream Runtime is the core component that enables secure and flexible execution of AI agent's action.
+The OpenHands Docker Runtime is the core component that enables secure and flexible execution of AI agent's action.
 It creates a sandboxed environment using Docker, where arbitrary code can be run safely without risking the host system.
 
 ## Why do we need a sandboxed runtime?
@@ -54,14 +54,13 @@ graph TD
 6. Action Execution: The runtime client receives actions from the backend, executes them in the sandboxed environment, and sends back observations
 7. Observation Return: The action execution server sends execution results back to the OpenHands backend as observations
 
-
 The role of the client:
+
 - It acts as an intermediary between the OpenHands backend and the sandboxed environment
 - It executes various types of actions (shell commands, file operations, Python code, etc.) safely within the container
 - It manages the state of the sandboxed environment, including the current working directory and loaded plugins
 - It formats and returns observations to the backend, ensuring a consistent interface for processing results
 
-
 ## How OpenHands builds and maintains OH Runtime images
 
 OpenHands' approach to building and managing runtime images ensures efficiency, consistency, and flexibility in creating and maintaining Docker images for both production and development environments.
@@ -78,16 +77,15 @@ Tags may be in one of 2 formats:
 - **Source Tag**: `oh_v{openhands_version}_{16_digit_lock_hash}_{16_digit_source_hash}`
   (e.g.: `oh_v0.9.9_1234567890abcdef_1234567890abcdef`)
 
-
 #### Source Tag - Most Specific
 
 This is the first 16 digits of the MD5 of the directory hash for the source directory. This gives a hash
 for only the openhands source
 
-
 #### Lock Tag
 
 This hash is built from the first 16 digits of the MD5 of:
+
 - The name of the base image upon which the image was built (e.g.: `nikolaik/python-nodejs:python3.12-nodejs22`)
 - The content of the `pyproject.toml` included in the image.
 - The content of the `poetry.lock` included in the image.

docs/modules/usage/cloud/cloud-github-resolver.md

@@ -0,0 +1,33 @@
+# Cloud GitHub Resolver
+
+The GitHub Resolver automates code fixes and provides intelligent assistance for your repositories.
+
+## Setup
+
+The Cloud GitHub Resolver is available automatically when you
+[grant OpenHands Cloud repository access](./openhands-cloud.md#adding-repository-access).
+
+## Usage
+
+After granting OpenHands Cloud repository access, you can use the Cloud GitHub Resolver on the issues and pull requests
+on the repository.
+
+### Issues
+
+On your repository, label an issue with `openhands`. OpenHands will:
+1. Comment on the issue to let you know it is working on it.
+    - You can click on the link to track the progress on OpenHands Cloud.
+2. Open a pull request if it determines that the issue has been successfully resolved.
+3. Comment on the issue with a summary of the performed tasks and a link to the pull request.
+
+
+### Pull Requests
+
+To get OpenHands to work on pull requests, use `@openhands` in top level or inline comments to:
+     - Ask questions
+     - Request updates
+     - Get code explanations
+
+OpenHands will:
+1. Comment on the PR to let you know it is working on it.
+2. Perform the task.