Remove param from docstring that does not exist in the append_file (#4060)

Regression fixed

.devcontainer/README.MD

@@ -1 +1 @@
-The files in this directory configure a development container for GitHub Codespaces.
+The files in this directory configure a development container for GitHub Codespaces.

.devcontainer/devcontainer.json

@@ -1,5 +1,5 @@
 {
-	"name": "OpenDevin Codespaces",
+	"name": "OpenHands Codespaces",
 	"image": "mcr.microsoft.com/devcontainers/universal",
 	"customizations":{
         "vscode":{

.github/ISSUE_TEMPLATE/bug_template.yml

@@ -1,5 +1,5 @@
 name: Bug
-description: Report a problem with OpenDevin
+description: Report a problem with OpenHands
 title: '[Bug]: '
 labels: ['bug']
 body:
@@ -28,8 +28,8 @@ body:
   - type: textarea
     id: current-version
     attributes:
-      label: Current OpenDevin version
-      description: What version of OpenDevin are you using? If you're running in docker, tell us the tag you're using (e.g. ghcr.io/opendevin/opendevin:0.3.1).
+      label: Current OpenHands version
+      description: What version of OpenHands are you using? If you're running in docker, tell us the tag you're using (e.g. ghcr.io/all-hands-ai/openhands:0.3.1).
       render: bash
     validations:
       required: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,6 +1,6 @@
 ---
 name: Feature Request
-about: Suggest an idea for OpenDevin features
+about: Suggest an idea for OpenHands features
 title: ''
 labels: 'enhancement'
 assignees: ''

.github/dependabot.yml

@@ -5,18 +5,34 @@
 
 version: 2
 updates:
-  - package-ecosystem: "pip" # See documentation for possible values
-    directory: "/" # Location of package manifests
+  - package-ecosystem: "pip"
+    directory: "/"
     schedule:
       interval: "daily"
     open-pull-requests-limit: 20
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/frontend" # Location of package manifests
+
+  - package-ecosystem: "npm"
+    directory: "/frontend"
     schedule:
       interval: "daily"
     open-pull-requests-limit: 20
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/docs" # Location of package manifests
+    groups:
+      docusaurus:
+        patterns:
+          - "*docusaurus*"
+      eslint:
+        patterns:
+          - "*eslint*"
+
+  - package-ecosystem: "npm"
+    directory: "/docs"
     schedule:
       interval: "daily"
     open-pull-requests-limit: 20
+    groups:
+      docusaurus:
+        patterns:
+          - "*docusaurus*"
+      eslint:
+        patterns:
+          - "*eslint*"

.github/pull_request_template.md

@@ -1,4 +1,4 @@
-**What is the problem that this fixes or functionality that this introduces? Does it fix any open issues?**
+**Short description of the problem this fixes or functionality that this introduces. This may be used for the CHANGELOG**
 
 
 
@@ -8,4 +8,4 @@
 
 
 ---
-**Other references**
+**Link of any specific issues this addresses**

.github/workflows/clean-up.yml

@@ -1,6 +1,7 @@
 # Workflow that cleans up outdated and old workflows to prevent out of disk issues
 name: Delete old workflow runs
 
+# This workflow is currently only triggered manually
 on:
   workflow_dispatch:
     inputs:

.github/workflows/deploy-docs.yml

@@ -1,6 +1,8 @@
 # Workflow that builds and deploys the documentation website
 name: Deploy Docs to GitHub Pages
 
+# * Always run on "main"
+# * Run on PRs that target the "main" branch and have changes in the "docs" folder or this workflow
 on:
   push:
     branches:
@@ -8,15 +10,16 @@ on:
   pull_request:
     paths:
       - 'docs/**'
+      - '.github/workflows/deploy-docs.yml'
     branches:
       - main
 
 jobs:
   # Build the documentation website
   build:
+    if: github.repository == 'All-Hands-AI/OpenHands'
     name: Build Docusaurus
     runs-on: ubuntu-latest
-    if: github.repository == 'OpenDevin/OpenDevin'
     steps:
       - uses: actions/checkout@v4
         with:
@@ -44,10 +47,14 @@ jobs:
 
   # Deploy the documentation website
   deploy:
+    if: github.ref == 'refs/heads/main' && github.repository == 'All-Hands-AI/OpenHands'
     name: Deploy to GitHub Pages
     runs-on: ubuntu-latest
+    # 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:
+      group: ${{ github.workflow }}-${{ github.ref }}
     needs: build
-    if: github.ref == 'refs/heads/main' && github.repository == 'OpenDevin/OpenDevin'
     # Grant GITHUB_TOKEN the permissions required to make a Pages deployment
     permissions:
       pages: write # to deploy to Pages

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

@@ -1,10 +1,8 @@
 # Workflow that uses the DummyAgent to run a simple task
 name: Run E2E test with dummy agent
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
-
+# Always run on "main"
+# Always run on PRs
 on:
   push:
     branches:
@@ -16,20 +14,38 @@ jobs:
     runs-on: ubuntu-latest
     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 poetry via pipx
+        run: pipx install poetry
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
           python-version: '3.11'
-      - name: Set up environment
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-          poetry install --without evaluation,llama-index
-          poetry run playwright install --with-deps chromium
-          wget https://huggingface.co/BAAI/bge-small-en-v1.5/raw/main/1_Pooling/config.json -P /tmp/llama_index/models--BAAI--bge-small-en-v1.5/snapshots/5c38ec7c405ec4b44b94cc5a9bb96e735b38267a/1_Pooling/
+          cache: 'poetry'
+      - name: Install Python dependencies using Poetry
+        run: poetry install --without evaluation,llama-index
+      - name: Build Environment
+        run: make build
       - name: Run tests
         run: |
           set -e
-          poetry run python opendevin/core/main.py -t "do a flip" -d ./workspace/ -c DummyAgent
+          poetry run python3 openhands/core/main.py -t "do a flip" -d ./workspace/ -c DummyAgent
       - name: Check exit code
         run: |
           if [ $? -ne 0 ]; then

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

@@ -0,0 +1,39 @@
+# Workflow that runs frontend unit tests
+name: Run Frontend Unit Tests
+
+# * Always run on "main"
+# * Run on PRs that have changes in the "frontend" folder or this workflow
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    paths:
+      - 'frontend/**'
+      -  '.github/workflows/fe-unit-tests.yml'
+
+jobs:
+  # Run frontend unit tests
+  fe-test:
+    name: FE Unit Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install dependencies
+        working-directory: ./frontend
+        run: npm ci
+      - name: Run tests and collect coverage
+        working-directory: ./frontend
+        run: npm run test:coverage
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/ghcr.yml

@@ -1,430 +0,0 @@
-# Workflow that builds, tests and then pushes the docker images to the ghcr.io repository
-name: Build Publish and Test Runtime Image
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
-
-on:
-  push:
-    branches:
-      - main
-    tags:
-      - '*'
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      reason:
-        description: 'Reason for manual trigger'
-        required: true
-        default: ''
-
-jobs:
-  # Builds the OpenDevin Docker images
-  ghcr_build:
-    runs-on: ubuntu-latest
-    outputs:
-      tags: ${{ steps.capture-tags.outputs.tags }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        image: ['opendevin']
-        platform: ['amd64', 'arm64']
-    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
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Build and export image
-        id: build
-        run: ./containers/build.sh ${{ matrix.image }} ${{ github.repository_owner }} ${{ matrix.platform }}
-      - name: Capture tags
-        id: capture-tags
-        run: |
-          tags=$(cat tags.txt)
-          echo "tags=$tags"
-          echo "tags=$tags" >> $GITHUB_OUTPUT
-      - name: Upload Docker image as artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.image }}-docker-image-${{ matrix.platform }}
-          path: /tmp/${{ matrix.image }}_image_${{ matrix.platform }}.tar
-          retention-days: 14
-
-  # Builds the runtime Docker images
-  ghcr_build_runtime:
-    runs-on: ubuntu-latest
-    outputs:
-      tags: ${{ steps.capture-tags.outputs.tags }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        image: ['od_runtime']
-        base_image: ['nikolaik/python-nodejs:python3.11-nodejs22']
-        platform: ['amd64', 'arm64']
-    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
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        id: buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Install poetry via pipx
-        run: pipx install poetry
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-          cache: 'poetry'
-      - name: Install Python dependencies using Poetry
-        run: make install-python-dependencies
-      - name: Create source distribution and Dockerfile
-        run: poetry run python3 opendevin/runtime/utils/runtime_build.py --base_image ${{ matrix.base_image }} --build_folder containers/runtime --force_rebuild
-      - name: Build and export image
-        id: build
-        run: |
-          if [ -f 'containers/runtime/Dockerfile' ]; then
-            echo 'Dockerfile detected, building runtime image...'
-            ./containers/build.sh ${{ matrix.image }} ${{ github.repository_owner }} ${{ matrix.platform }}
-          else
-            echo 'No Dockerfile detected which means an exact image is already built. Pulling the image and saving it to a tar file...'
-            source containers/runtime/config.sh
-            echo "$DOCKER_IMAGE_TAG $DOCKER_IMAGE_HASH_TAG" >> tags.txt
-            echo "Pulling image $DOCKER_IMAGE/$DOCKER_IMAGE_HASH_TAG to /tmp/${{ matrix.image }}_image_${{ matrix.platform }}.tar"
-            docker pull $DOCKER_IMAGE:$DOCKER_IMAGE_HASH_TAG
-            docker save $DOCKER_IMAGE:$DOCKER_IMAGE_HASH_TAG -o /tmp/${{ matrix.image }}_image_${{ matrix.platform }}.tar
-          fi
-      - name: Capture tags
-        id: capture-tags
-        run: |
-          tags=$(cat tags.txt)
-          echo "tags=$tags"
-          echo "tags=$tags" >> $GITHUB_OUTPUT
-      - name: Upload Docker image as artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.image }}-docker-image-${{ matrix.platform }}
-          path: /tmp/${{ matrix.image }}_image_${{ matrix.platform }}.tar
-          retention-days: 14
-
-  # Run unit tests with the EventStream and Server runtime Docker images
-  test_runtime:
-    name: Test Runtime
-    runs-on: ubuntu-latest
-    needs: [ghcr_build_runtime, ghcr_build]
-    strategy:
-      matrix:
-        runtime_type: ['eventstream']
-    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,
-          # when 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
-          swap-storage: true
-      - name: Install poetry via pipx
-        run: pipx install poetry
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-          cache: 'poetry'
-      - name: Install Python dependencies using Poetry
-        run: make install-python-dependencies
-      - name: Download Runtime Docker image
-        if: matrix.runtime_type == 'eventstream'
-        uses: actions/download-artifact@v4
-        with:
-          name: od_runtime-docker-image-amd64
-          path: /tmp/
-      - name: Download Sandbox Docker image
-        if: matrix.runtime_type == 'server'
-        uses: actions/download-artifact@v4
-        with:
-          name: sandbox-docker-image-amd64
-          path: /tmp/
-      - name: Load Runtime image and run runtime tests
-        run: |
-          # Load the Docker image and capture the output
-          if [ "${{ matrix.runtime_type }}" == "eventstream" ]; then
-            output=$(docker load -i /tmp/od_runtime_image_amd64.tar)
-          else
-            output=$(docker load -i /tmp/sandbox_image_amd64.tar)
-          fi
-
-          # Extract the first image name from the output
-          image_name=$(echo "$output" | grep -oP 'Loaded image: \K.*' | head -n 1)
-
-          # Print the full name of the image
-          echo "Loaded Docker image: $image_name"
-
-          TEST_RUNTIME=${{ matrix.runtime_type }} SANDBOX_USER_ID=$(id -u) SANDBOX_CONTAINER_IMAGE=$image_name TEST_IN_CI=true poetry run pytest --cov=agenthub --cov=opendevin --cov-report=xml -s ./tests/unit/test_runtime.py
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-  # Run integration tests with the eventstream runtime Docker image
-  runtime_integration_tests_on_linux:
-    name: Runtime Integration Tests on Linux
-    runs-on: ubuntu-latest
-    needs: [ghcr_build_runtime]
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ['3.11']
-        # server is tested in a separate workflow
-        runtime_type: ['eventstream']
-    steps:
-      - uses: actions/checkout@v4
-      - 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: Install Python dependencies using Poetry
-        run: make install-python-dependencies
-      - name: Download Runtime Docker image
-        uses: actions/download-artifact@v4
-        with:
-          name: od_runtime-docker-image-amd64
-          path: /tmp/
-      - name: Load runtime image and run integration tests
-        run: |
-          # Load the Docker image and capture the output
-          if [ "${{ matrix.runtime_type }}" == "eventstream" ]; then
-            output=$(docker load -i /tmp/od_runtime_image_amd64.tar)
-          else
-            echo "No Runtime Docker image to load"
-            exit 1
-          fi
-
-          # Extract the first image name from the output
-          image_name=$(echo "$output" | grep -oP 'Loaded image: \K.*' | head -n 1)
-
-          # Print the full name of the image
-          echo "Loaded Docker image: $image_name"
-
-          TEST_RUNTIME=${{ matrix.runtime_type }} SANDBOX_USER_ID=$(id -u) SANDBOX_CONTAINER_IMAGE=$image_name TEST_IN_CI=true TEST_ONLY=true ./tests/integration/regenerate.sh
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-  # Push the OpenDevin and sandbox Docker images to the ghcr.io repository
-  ghcr_push:
-    runs-on: ubuntu-latest
-    needs: [ghcr_build]
-    if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')
-    env:
-      tags: ${{ needs.ghcr_build.outputs.tags }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        image: ['opendevin']
-        platform: ['amd64', 'arm64']
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Login to GHCR
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Download Docker images
-        uses: actions/download-artifact@v4
-        with:
-          name: ${{ matrix.image }}-docker-image-${{ matrix.platform }}
-          path: /tmp/${{ matrix.platform }}
-      - name: Load images and push to registry
-        run: |
-          mv /tmp/${{ matrix.platform }}/${{ matrix.image }}_image_${{ matrix.platform }}.tar .
-          loaded_image=$(docker load -i ${{ matrix.image }}_image_${{ matrix.platform }}.tar | grep "Loaded image:" | head -n 1 | awk '{print $3}')
-          echo "loaded image = $loaded_image"
-          tags=$(echo ${tags} | tr ' ' '\n')
-          image_name=$(echo "ghcr.io/${{ github.repository_owner }}/${{ matrix.image }}" | tr '[:upper:]' '[:lower:]')
-          echo "image name = $image_name"
-          for tag in $tags; do
-            echo "tag = $tag"
-            docker tag $loaded_image $image_name:${tag}_${{ matrix.platform }}
-            docker push $image_name:${tag}_${{ matrix.platform }}
-          done
-
-  # Push the runtime Docker images to the ghcr.io repository
-  ghcr_push_runtime:
-    runs-on: ubuntu-latest
-    needs: [ghcr_build_runtime, test_runtime, runtime_integration_tests_on_linux]
-    if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')
-    env:
-      RUNTIME_TAGS: ${{ needs.ghcr_build_runtime.outputs.tags }}
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      matrix:
-        image: ['od_runtime']
-        platform: ['amd64', 'arm64']
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Free Disk Space (Ubuntu)
-        uses: jlumbroso/free-disk-space@main
-        with:
-          tool-cache: true
-          android: true
-          dotnet: true
-          haskell: true
-          large-packages: true
-          docker-images: false
-          swap-storage: true
-      - name: Login to GHCR
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Download Docker images
-        uses: actions/download-artifact@v4
-        with:
-          name: ${{ matrix.image }}-docker-image-${{ matrix.platform }}
-          path: /tmp/${{ matrix.platform }}
-      - name: List downloaded files
-        run: |
-          ls -la /tmp/${{ matrix.platform }}
-          file /tmp/${{ matrix.platform }}/*
-      - name: Load images and push to registry
-        run: |
-          mv /tmp/${{ matrix.platform }}/${{ matrix.image }}_image_${{ matrix.platform }}.tar ./${{ matrix.image }}_image_${{ matrix.platform }}.tar
-          if ! loaded_image=$(docker load -i ${{ matrix.image }}_image_${{ matrix.platform }}.tar | grep "Loaded image:" | head -n 1 | awk '{print $3}'); then
-            echo "Failed to load Docker image"
-            exit 1
-          fi
-          echo "loaded image = $loaded_image"
-          image_name=$(echo "ghcr.io/${{ github.repository_owner }}/${{ matrix.image }}" | tr '[:upper:]' '[:lower:]')
-          echo "image name = $image_name"
-          echo "$RUNTIME_TAGS" | tr ' ' '\n' | while read -r tag; do
-            echo "tag = $tag"
-            if [ -n "$image_name" ] && [ -n "$tag" ]; then
-              docker tag $loaded_image $image_name:${tag}_${{ matrix.platform }}
-              docker push $image_name:${tag}_${{ matrix.platform }}
-            else
-              echo "Skipping tag and push due to empty image_name or tag"
-            fi
-          done
-
-  # Creates and pushes the OpenDevin and sandbox Docker image manifests
-  create_manifest:
-    runs-on: ubuntu-latest
-    needs: [ghcr_build, ghcr_push]
-    if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')
-    env:
-      tags: ${{ needs.ghcr_build.outputs.tags }}
-    strategy:
-      matrix:
-        image: ['opendevin']
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Login to GHCR
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Create and push multi-platform manifest
-        run: |
-          image_name=$(echo "ghcr.io/${{ github.repository_owner }}/${{ matrix.image }}" | tr '[:upper:]' '[:lower:]')
-          echo "image name = $image_name"
-          tags=$(echo ${tags} | tr ' ' '\n')
-          for tag in $tags; do
-            echo 'tag = $tag'
-            docker buildx imagetools create --tag $image_name:$tag \
-              $image_name:${tag}_amd64 \
-              $image_name:${tag}_arm64
-          done
-
-  # Creates and pushes the runtime Docker image manifest
-  create_manifest_runtime:
-    runs-on: ubuntu-latest
-    needs: [ghcr_build_runtime, ghcr_push_runtime]
-    if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')
-    env:
-      tags: ${{ needs.ghcr_build_runtime.outputs.tags }}
-    strategy:
-      matrix:
-        image: ['od_runtime']
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Login to GHCR
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Create and push multi-platform manifest
-        run: |
-          image_name=$(echo "ghcr.io/${{ github.repository_owner }}/${{ matrix.image }}" | tr '[:upper:]' '[:lower:]')
-          echo "image name = $image_name"
-          tags=$(echo ${tags} | tr ' ' '\n')
-          for tag in $tags; do
-            echo 'tag = $tag'
-            docker buildx imagetools create --tag $image_name:$tag \
-              $image_name:${tag}_amd64 \
-              $image_name:${tag}_arm64
-          done

.github/workflows/ghcr_app.yml

@@ -0,0 +1,65 @@
+# Workflow that builds, tests and then pushes the app docker images to the ghcr.io repository
+name: Build and Publish App Image
+
+# Always run on "main"
+# Always run on tags
+# Always run on PRs
+# Can also be triggered manually
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - '*'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for manual trigger'
+        required: true
+        default: ''
+
+jobs:
+  # Builds the OpenHands Docker images
+  ghcr_build:
+    name: Build App Image
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    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
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Login to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Build and push app image
+        if: "!github.event.pull_request.head.repo.fork"
+        run: |
+          ./containers/build.sh openhands ${{ github.repository_owner }} --push
+      - name: Build app image
+        if: "github.event.pull_request.head.repo.fork"
+        run: |
+          ./containers/build.sh openhands image ${{ github.repository_owner }}

.github/workflows/ghcr_runtime.yml

@@ -0,0 +1,358 @@
+# Workflow that builds, tests and then pushes the runtime docker images to the ghcr.io repository
+name: Build, Test and Publish RT Image
+
+# Only run one workflow of the same group at a time.
+# There can be at most one running and one pending job in a concurrency group at any time.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Always run on "main"
+# Always run on tags
+# Always run on PRs
+# Can also be triggered manually
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - '*'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for manual trigger'
+        required: true
+        default: ''
+
+jobs:
+  # Builds the runtime Docker images
+  ghcr_build_runtime:
+    name: Build Image
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        base_image:
+          - image: 'nikolaik/python-nodejs:python3.11-nodejs22'
+            tag: nikolaik
+    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
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Login to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - 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 poetry via pipx
+        run: pipx install poetry
+      - name: Install Python dependencies using Poetry
+        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: Build and push runtime image ${{ matrix.base_image.image }}
+        if: github.event.pull_request.head.repo.fork != true
+        run: |
+          ./containers/build.sh runtime ${{ github.repository_owner }} --push ${{ 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:${{ github.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
+        if: github.event.pull_request.head.repo.fork
+        uses: actions/upload-artifact@v4
+        with:
+          name: runtime-${{ matrix.base_image.tag }}
+          path: /tmp/runtime-${{ matrix.base_image.tag }}.tar
+
+  # Run unit tests with the EventStream runtime Docker images as root
+  test_runtime_root:
+    name: RT Unit Tests (Root)
+    needs: [ghcr_build_runtime]
+    runs-on: ubuntu-latest
+    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
+      # Forked repos can't push to GHCR, so we need to download the image as an artifact
+      - name: Download runtime image for fork
+        if: github.event.pull_request.head.repo.fork
+        uses: actions/download-artifact@v4
+        with:
+          name: runtime-${{ matrix.base_image }}
+          path: /tmp
+      - name: Load runtime image for fork
+        if: github.event.pull_request.head.repo.fork
+        run: |
+          docker load --input /tmp/runtime-${{ matrix.base_image }}.tar
+      - 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: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install poetry via pipx
+        run: pipx install poetry
+      - name: Install Python dependencies using Poetry
+        run: make install-python-dependencies
+      - name: Run runtime tests
+        run: |
+          # We install pytest-xdist in order to run tests across CPUs
+          poetry run pip install pytest-xdist
+
+          # 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:${{ github.sha }}-${{ matrix.base_image }}
+          image_name=$(echo $image_name | tr '[:upper:]' '[:lower:]')
+
+          SKIP_CONTAINER_LOGS=true \
+          TEST_RUNTIME=eventstream \
+          SANDBOX_USER_ID=$(id -u) \
+          SANDBOX_RUNTIME_CONTAINER_IMAGE=$image_name \
+          TEST_IN_CI=true \
+          RUN_AS_OPENHANDS=false \
+          poetry run pytest -n 3 -raR --reruns 1 --reruns-delay 3 --cov=agenthub --cov=openhands --cov-report=xml -s ./tests/runtime
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  # Run unit tests with the EventStream runtime Docker images as openhands user
+  test_runtime_oh:
+    name: RT Unit Tests (openhands)
+    runs-on: ubuntu-latest
+    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
+      # Forked repos can't push to GHCR, so we need to download the image as an artifact
+      - name: Download runtime image for fork
+        if: github.event.pull_request.head.repo.fork
+        uses: actions/download-artifact@v4
+        with:
+          name: runtime-${{ matrix.base_image }}
+          path: /tmp
+      - name: Load runtime image for fork
+        if: github.event.pull_request.head.repo.fork
+        run: |
+          docker load --input /tmp/runtime-${{ matrix.base_image }}.tar
+      - 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: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install poetry via pipx
+        run: pipx install poetry
+      - name: Install Python dependencies using Poetry
+        run: make install-python-dependencies
+      - name: Run runtime tests
+        run: |
+          # We install pytest-xdist in order to run tests across CPUs
+          poetry run pip install pytest-xdist
+
+          # 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:${{ github.sha }}-${{ matrix.base_image }}
+          image_name=$(echo $image_name | tr '[:upper:]' '[:lower:]')
+
+          SKIP_CONTAINER_LOGS=true \
+          TEST_RUNTIME=eventstream \
+          SANDBOX_USER_ID=$(id -u) \
+          SANDBOX_RUNTIME_CONTAINER_IMAGE=$image_name \
+          TEST_IN_CI=true \
+          RUN_AS_OPENHANDS=true \
+          poetry run pytest -n 3 -raR --reruns 1 --reruns-delay 3 --cov=agenthub --cov=openhands --cov-report=xml -s ./tests/runtime
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  # Run integration tests with the eventstream runtime Docker image
+  runtime_integration_tests_on_linux:
+    name: RT Integration Tests (Linux)
+    runs-on: ubuntu-latest
+    needs: [ghcr_build_runtime]
+    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
+      # Forked repos can't push to GHCR, so we need to download the image as an artifact
+      - name: Download runtime image for fork
+        if: github.event.pull_request.head.repo.fork
+        uses: actions/download-artifact@v4
+        with:
+          name: runtime-${{ matrix.base_image }}
+          path: /tmp
+      - name: Load runtime image for fork
+        if: github.event.pull_request.head.repo.fork
+        run: |
+          docker load --input /tmp/runtime-${{ matrix.base_image }}.tar
+      - 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: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install poetry via pipx
+        run: pipx install poetry
+      - name: Install Python dependencies using Poetry
+        run: make install-python-dependencies
+      - name: Run integration tests
+        run: |
+          image_name=ghcr.io/${{ github.repository_owner }}/runtime:${{ github.sha }}-${{ matrix.base_image }}
+          image_name=$(echo $image_name | tr '[:upper:]' '[:lower:]')
+
+          TEST_RUNTIME=eventstream \
+          SANDBOX_USER_ID=$(id -u) \
+          SANDBOX_RUNTIME_CONTAINER_IMAGE=$image_name \
+          TEST_IN_CI=true \
+          TEST_ONLY=true \
+          ./tests/integration/regenerate.sh
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  # The two following jobs (named identically) are to check whether all the runtime tests have passed as the
+  # "All Runtime Tests Passed" is a required job for PRs to merge
+  # Due to this bug: https://github.com/actions/runner/issues/2566, we want to create a job that runs when the
+  # prerequisites have been cancelled or failed so merging is disallowed, otherwise Github considers "skipped" as "success"
+  runtime_tests_check_success:
+    name: All Runtime Tests Passed
+    if: ${{ !cancelled() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}
+    runs-on: ubuntu-latest
+    needs: [test_runtime_root, test_runtime_oh, runtime_integration_tests_on_linux]
+    steps:
+      - name: All tests passed
+        run: echo "All runtime tests have passed successfully!"
+
+  runtime_tests_check_fail:
+    name: All Runtime Tests Passed
+    if: ${{ cancelled() || contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}
+    runs-on: ubuntu-latest
+    needs: [test_runtime_root, test_runtime_oh, runtime_integration_tests_on_linux]
+    steps:
+      - name: Some tests failed
+        run: |
+          echo "Some runtime tests failed or were cancelled"
+          exit 1

.github/workflows/lint.yml

@@ -1,10 +1,9 @@
 # Workflow that runs lint on the frontend and python code
 name: Lint
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
-
+# The jobs in this workflow are required, so they must run at all times
+# Always run on "main"
+# Always run on PRs
 on:
   push:
     branches:
@@ -47,4 +46,4 @@ jobs:
       - name: Install pre-commit
         run: pip install pre-commit==3.7.0
       - name: Run pre-commit hooks
-        run: pre-commit run --files opendevin/**/* agenthub/**/* evaluation/**/* tests/**/* --show-diff-on-failure --config ./dev_config/python/.pre-commit-config.yaml
+        run: pre-commit run --files openhands/**/* agenthub/**/* evaluation/**/* tests/**/* --show-diff-on-failure --config ./dev_config/python/.pre-commit-config.yaml

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

@@ -1,50 +1,19 @@
-# Workflow that runs frontend and python unit tests
-name: Run Unit Tests
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+# Workflow that runs python unit tests
+name: Run Python Unit Tests
 
+# The jobs in this workflow are required, so they must run at all times
+# * Always run on "main"
+# * Always run on PRs
 on:
   push:
     branches:
       - main
-    paths-ignore:
-      - '**/*.md'
-      - 'frontend/**'
-      - 'docs/**'
-      - 'evaluation/**'
   pull_request:
 
-
 jobs:
-  # Run frontend unit tests
-  fe-test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [20]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Install dependencies
-        working-directory: ./frontend
-        run: npm ci
-      - name: Run tests and collect coverage
-        working-directory: ./frontend
-        run: npm run test:coverage
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
   # Run python unit tests on macOS
   test-on-macos:
-    name: Test on macOS
+    name: Python Unit Tests on macOS
     runs-on: macos-12
     env:
       INSTALL_DOCKER: '1' # Set to '0' to skip Docker installation
@@ -53,13 +22,21 @@ jobs:
         python-version: ['3.11']
     steps:
       - uses: actions/checkout@v4
-      - name: Install poetry via pipx
-        run: pipx install poetry
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
-          cache: 'poetry'
+      - 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 poetry via pipx
+        run: pipx install poetry
       - name: Install Python dependencies using Poetry
         run: poetry install --without evaluation,llama-index
       - name: Install & Start Docker
@@ -112,8 +89,11 @@ jobs:
           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=agenthub --cov=opendevin --cov-report=xml ./tests/unit -k "not test_runtime.py"
+        run: poetry run pytest --forked --cov=agenthub --cov=openhands --cov-report=xml ./tests/unit
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4
         env:
@@ -121,7 +101,7 @@ jobs:
 
   # Run python unit tests on Linux
   test-on-linux:
-    name: Test on Linux
+    name: Python Unit Tests on Linux
     runs-on: ubuntu-latest
     env:
       INSTALL_DOCKER: '0' # Set to '0' to skip Docker installation
@@ -130,6 +110,9 @@ jobs:
         python-version: ['3.11']
     steps:
       - uses: actions/checkout@v4
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
       - name: Install poetry via pipx
         run: pipx install poetry
       - name: Set up Python
@@ -142,7 +125,7 @@ jobs:
       - name: Build Environment
         run: make build
       - name: Run Tests
-        run: poetry run pytest --forked --cov=agenthub --cov=opendevin --cov-report=xml ./tests/unit -k "not test_runtime.py"
+        run: poetry run pytest --forked --cov=agenthub --cov=openhands --cov-report=xml -svv ./tests/unit
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4
         env:

.github/workflows/pypi-release.yml

@@ -0,0 +1,31 @@
+# Publishes the OpenHands PyPi package
+name: Publish PyPi Package
+
+# Triggered manually
+on:
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for manual trigger'
+        required: true
+        default: ''
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.11
+      - name: Install Poetry
+        uses: snok/install-poetry@v1.4.1
+        with:
+          virtualenvs-in-project: true
+          virtualenvs-path: ~/.virtualenvs
+      - name: Install Poetry Dependencies
+        run: poetry install --no-interaction --no-root
+      - name: Build poetry project
+        run: poetry build -v
+      - name: publish
+        run: poetry publish -u __token__ -p ${{ secrets.PYPI_TOKEN }}

.github/workflows/regenerate_integration_tests.yml

@@ -0,0 +1,73 @@
+
+name: Regenerate Integration Tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      debug:
+        description: 'Enable debug mode'
+        type: boolean
+        default: true
+      log_to_file:
+        description: 'Enable logging to file'
+        type: boolean
+        default: true
+      force_regenerate_tests:
+        description: 'Force regeneration of tests'
+        type: boolean
+        default: false
+      force_use_llm:
+        description: 'Force use of LLM'
+        type: boolean
+        default: false
+
+jobs:
+  regenerate_integration_tests:
+    if: github.ref != 'refs/heads/main'
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+    - name: Set up Docker Buildx
+      id: buildx
+      uses: docker/setup-buildx-action@v3
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+    - 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 poetry via pipx
+      run: pipx install poetry
+    - name: Install Python dependencies using Poetry
+      run: make install-python-dependencies
+    - name: Build Environment
+      run: make build
+    - name: Regenerate integration tests
+      run: |
+        DEBUG=${{ inputs.debug }} \
+        LOG_TO_FILE=${{ inputs.log_to_file }} \
+        FORCE_REGENERATE_TESTS=${{ inputs.force_regenerate_tests }} \
+        FORCE_USE_LLM=${{ inputs.force_use_llm }} \
+        ./tests/integration/regenerate.sh
+    - name: Commit changes
+      run: |
+        if git diff --quiet --exit-code; then
+          echo "No changes to commit"
+          exit 0
+        fi
+
+        git config --global user.name 'github-actions[bot]'
+        git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+        git add .
+        # run it twice in case pre-commit makes changes
+        git commit -am "Regenerate integration tests" || git commit -am "Regenerate integration tests"
+        git push

.github/workflows/review-pr.yml

@@ -1,5 +1,5 @@
-# Workflow that uses OpenDevin to review a pull request. PR must be labeled 'review-this'
-name: Use OpenDevin to Review Pull Request
+# Workflow that uses OpenHands to review a pull request. PR must be labeled 'review-this'
+name: Use OpenHands to Review Pull Request
 
 on:
   pull_request:
@@ -15,6 +15,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
+    - name: Set up Docker Buildx
+      id: buildx
+      uses: docker/setup-buildx-action@v3
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
@@ -49,7 +52,7 @@ jobs:
         export PATH="/github/home/.local/bin:$PATH"
         poetry install --without evaluation,llama-index
         poetry run playwright install --with-deps chromium
-    - name: Run OpenDevin
+    - name: Run OpenHands
       env:
         LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
         LLM_MODEL: ${{ vars.LLM_MODEL }}
@@ -60,7 +63,7 @@ jobs:
         export PYTHONPATH=$(pwd):$PYTHONPATH
         export WORKSPACE_MOUNT_PATH=$GITHUB_WORKSPACE
         export WORKSPACE_BASE=$GITHUB_WORKSPACE
-        echo -e "/exit\n" | poetry run python opendevin/core/main.py -i 50 -f task.txt
+        echo -e "/exit\n" | poetry run python openhands/core/main.py -i 50 -f task.txt
         rm task.txt
     - name: Check if review file is non-empty
       id: check_file

.github/workflows/solve-issue.yml

@@ -1,5 +1,5 @@
-# Workflow that uses OpenDevin to resolve a GitHub issue. Issue must be labeled 'solve-this'
-name: Use OpenDevin to Resolve GitHub Issue
+# Workflow that uses OpenHands to resolve a GitHub issue. Issue must be labeled 'solve-this'
+name: Use OpenHands to Resolve GitHub Issue
 
 on:
   issues:
@@ -15,12 +15,15 @@ jobs:
     if: github.event.label.name == 'solve-this'
     runs-on: ubuntu-latest
     container:
-      image: ghcr.io/opendevin/opendevin
+      image: ghcr.io/all-hands-ai/openhands
       volumes:
         - /var/run/docker.sock:/var/run/docker.sock
     steps:
     - name: install git, github cli
       run: apt-get install -y git gh
+    - name: Set up Docker Buildx
+      id: buildx
+      uses: docker/setup-buildx-action@v3
     - name: Checkout Repository
       uses: actions/checkout@v4
     - name: Write Task File
@@ -39,7 +42,7 @@ jobs:
         export PATH="/github/home/.local/bin:$PATH"
         poetry install --without evaluation,llama-index
         poetry run playwright install --with-deps chromium
-    - name: Run OpenDevin
+    - name: Run OpenHands
       env:
         ISSUE_TITLE: ${{ github.event.issue.title }}
         ISSUE_BODY: ${{ github.event.issue.body }}
@@ -50,14 +53,14 @@ jobs:
         export PATH="/github/home/.local/bin:$PATH"
         # Append path to correctly import package, note: must set pwd at first
         export PYTHONPATH=$(pwd):$PYTHONPATH
-        WORKSPACE_MOUNT_PATH=$GITHUB_WORKSPACE poetry run python ./opendevin/core/main.py -i 50 -f task.txt -d $GITHUB_WORKSPACE
+        WORKSPACE_MOUNT_PATH=$GITHUB_WORKSPACE poetry run python ./openhands/core/main.py -i 50 -f task.txt -d $GITHUB_WORKSPACE
         rm task.txt
     - name: Setup Git, Create Branch, and Commit Changes
       run: |
         # Setup Git configuration
         git config --global --add safe.directory $PWD
-        git config --global user.name 'OpenDevin'
-        git config --global user.email 'OpenDevin@users.noreply.github.com'
+        git config --global user.name 'OpenHands'
+        git config --global user.email 'OpenHands@users.noreply.github.com'
 
         # Create a unique branch name with a timestamp
         BRANCH_NAME="fix/${{ github.event.issue.number }}-$(date +%Y%m%d%H%M%S)"
@@ -69,7 +72,7 @@ jobs:
         git add --all -- ':!task.txt'
 
         # Commit the changes, if any
-        git commit -m "OpenDevin: Resolve Issue #${{ github.event.issue.number }}"
+        git commit -m "OpenHands: Resolve Issue #${{ github.event.issue.number }}"
         if [ $? -ne 0 ]; then
           echo "No changes to commit."
           exit 0
@@ -91,9 +94,9 @@ jobs:
       run: |
         # Create PR and capture URL
         PR_URL=$(gh pr create \
-          --title "OpenDevin: Resolve Issue #2" \
-          --body "This PR was generated by OpenDevin to resolve issue #2" \
-          --repo "foragerr/OpenDevin" \
+          --title "OpenHands: Resolve Issue #2" \
+          --body "This PR was generated by OpenHands to resolve issue #2" \
+          --repo "foragerr/OpenHands" \
           --head "${{ github.head_ref }}" \
           --base "${{ env.DEFAULT_BRANCH }}" \
           | grep -o 'https://github.com/[^ ]*')
@@ -110,4 +113,4 @@ jobs:
         GH_TOKEN: ${{ github.token }}
       run: |
         gh issue comment ${{ github.event.issue.number }} \
-          -b "OpenDevin raised [PR #${{ env.PR_NUMBER }}](${{ env.PR_URL }}) to resolve this issue."
+          -b "OpenHands raised [PR #${{ env.PR_NUMBER }}](${{ env.PR_URL }}) to resolve this issue."

.github/workflows/stale.yml

@@ -1,6 +1,7 @@
 # Workflow that marks issues and PRs with no activity for 30 days with "Stale" and closes them after 7 more days of no activity
 name: 'Close stale issues'
 
+# Runs every day at 01:30
 on:
   schedule:
     - cron: '30 1 * * *'
@@ -14,6 +15,7 @@ jobs:
           stale-issue-message: 'This issue is stale because it has been open for 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
           stale-pr-message: 'This PR is stale because it has been open for 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
           days-before-stale: 30
+          exempt-issue-labels: 'tracked'
           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

.gitignore

@@ -223,8 +223,9 @@ containers/agnostic_sandbox
 image_build_logs
 run_instance_logs
 
-od_runtime_*.tar
+runtime_*.tar
 
 # docker build
 containers/runtime/Dockerfile
 containers/runtime/project.tar.gz
+containers/runtime/code

CONTRIBUTING.md

@@ -1,35 +1,35 @@
 # Contributing
 
-Thanks for your interest in contributing to OpenDevin! We welcome and appreciate contributions.
+Thanks for your interest in contributing to OpenHands! We welcome and appreciate contributions.
 
 ## How Can I Contribute?
 
 There are many ways that you can contribute:
 
-1. **Download and use** OpenDevin, and send [issues](https://github.com/OpenDevin/OpenDevin/issues) when you encounter something that isn't working or a feature that you'd like to see.
+1. **Download and use** OpenHands, and send [issues](https://github.com/All-Hands-AI/OpenHands/issues) when you encounter something that isn't working or a feature that you'd like to see.
 2. **Send feedback** after each session by [clicking the thumbs-up thumbs-down buttons](https://docs.all-hands.dev/modules/usage/feedback), so we can see where things are working and failing, and also build an open dataset for training code agents.
-3. **Improve the Codebase** by sending PRs (see details below). In particular, we have some [good first issue](https://github.com/OpenDevin/OpenDevin/labels/good%20first%20issue) issues that may be ones to start on.
+3. **Improve the Codebase** by sending PRs (see details below). In particular, we have some [good first issue](https://github.com/All-Hands-AI/OpenHands/labels/good%20first%20issue) issues that may be ones to start on.
 
-## Understanding OpenDevin's CodeBase
+## Understanding OpenHands's CodeBase
 
 To understand the codebase, please refer to the README in each module:
 - [frontend](./frontend/README.md)
 - [agenthub](./agenthub/README.md)
 - [evaluation](./evaluation/README.md)
-- [opendevin](./opendevin/README.md)
-    - [server](./opendevin/server/README.md)
+- [openhands](./openhands/README.md)
+    - [server](./openhands/server/README.md)
 
 When you write code, it is also good to write tests. Please navigate to the `tests` folder to see existing test suites.
 At the moment, we have two kinds of tests: `unit` and `integration`. Please refer to the README for each test suite. These tests also run on GitHub's continuous integration to ensure quality of the project.
 
-## Sending Pull Requests to OpenDevin
+## Sending Pull Requests to OpenHands
 
 ### 1. Fork the Official Repository
-Fork the [OpenDevin repository](https://github.com/OpenDevin/OpenDevin) into your own account.
+Fork the [OpenHands repository](https://github.com/All-Hands-AI/OpenHands) into your own account.
 Clone your own forked repository into your local environment:
 
 ```shell
-git clone git@github.com:<YOUR-USERNAME>/OpenDevin.git
+git clone git@github.com:<YOUR-USERNAME>/OpenHands.git
 ```
 
 ### 2. Configure Git
@@ -38,8 +38,8 @@ Set the official repository as your [upstream](https://www.atlassian.com/git/tut
 Add the original repository as upstream:
 
 ```shell
-cd OpenDevin
-git remote add upstream git@github.com:OpenDevin/OpenDevin.git
+cd OpenHands
+git remote add upstream git@github.com:All-Hands-AI/OpenHands.git
 ```
 
 Verify that the remote is set:
@@ -62,7 +62,7 @@ git push origin main
 
 ### 4. Set up the Development Environment
 
-We have a separate doc [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md) that tells you how to set up a development workflow.
+We have a separate doc [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md) that tells you how to set up a development workflow.
 
 ### 5. Write Code and Commit It
 
@@ -80,13 +80,13 @@ git push origin my_branch
 * On GitHub, go to the page of your forked repository, and create a Pull Request:
    - Click on `Branches`
    - Click on the `...` beside your branch and click on `New pull request`
-   - Set `base repository` to `OpenDevin/OpenDevin`
+   - Set `base repository` to `All-Hands-AI/OpenHands`
    - Set `base` to `main`
    - Click `Create pull request`
 
-The PR should appear in [OpenDevin PRs](https://github.com/OpenDevin/OpenDevin/pulls).
+The PR should appear in [OpenHands PRs](https://github.com/All-Hands-AI/OpenHands/pulls).
 
-Then the OpenDevin team will review your code.
+Then the OpenHands team will review your code.
 
 ## PR Rules
 
@@ -109,7 +109,7 @@ For example, a PR title could be:
 - `refactor: modify package path`
 - `feat(frontend): xxxx`, where `(frontend)` means that this PR mainly focuses on the frontend component.
 
-You may also check out previous PRs in the [PR list](https://github.com/OpenDevin/OpenDevin/pulls).
+You may also check out previous PRs in the [PR list](https://github.com/All-Hands-AI/OpenHands/pulls).
 
 ### 2. Pull Request description
 - If your PR is small (such as a typo fix), you can go brief.

CREDITS.md

@@ -0,0 +1,312 @@
+# Credits
+
+## Contributors
+
+We would like to thank all the [contributors](https://github.com/All-Hands-AI/OpenHands/graphs/contributors) who have helped make OpenHands possible. Your dedication and hard work are greatly appreciated.
+
+## Open Source Projects
+
+OpenHands includes and adapts the following open source projects. We are grateful for their contributions to the open source community:
+
+#### [SWE Agent](https://github.com/princeton-nlp/swe-agent)
+   - License: MIT License
+   - Description: Adapted for use in OpenHands's agenthub
+
+#### [Aider](https://github.com/paul-gauthier/aider)
+   - License: Apache License 2.0
+   - Description: AI pair programming tool. OpenHands has adapted and integrated its linter module for code-related tasks in [`agentskills utilities`](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/runtime/plugins/agent_skills/utils/aider)
+
+#### [BrowserGym](https://github.com/ServiceNow/BrowserGym)
+   - License: Apache License 2.0
+   - Description: Adapted in implementing the browsing agent
+
+
+### Reference Implementations for Evaluation Benchmarks
+OpenHands integrates code of the reference implementations for the following agent evaluation benchmarks:
+
+#### [HumanEval](https://github.com/openai/human-eval)
+   - License: MIT License
+
+#### [DSP](https://github.com/microsoft/DataScienceProblems)
+   - License: MIT License
+
+#### [HumanEvalPack](https://github.com/bigcode-project/bigcode-evaluation-harness)
+   - License: Apache License 2.0
+
+#### [AgentBench](https://github.com/THUDM/AgentBench)
+   - License: Apache License 2.0
+
+#### [SWE-Bench](https://github.com/princeton-nlp/SWE-bench)
+   - License: MIT License
+
+#### [BIRD](https://bird-bench.github.io/)
+   - License: MIT License
+   - Dataset: CC-BY-SA 4.0
+
+#### [Gorilla APIBench](https://github.com/ShishirPatil/gorilla)
+   - License: Apache License 2.0
+
+#### [GPQA](https://github.com/idavidrein/gpqa)
+   - License: MIT License
+
+#### [ProntoQA](https://github.com/asaparov/prontoqa)
+   - License: Apache License 2.0
+
+
+## Open Source licenses
+
+### MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+### BSD 3-Clause License
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+### Apache License 2.0
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+
+
+### Non-Open Source Reference Implementations:
+
+#### [MultiPL-E](https://github.com/nuprl/MultiPL-E)
+   - License: BSD 3-Clause License with Machine Learning Restriction
+
+BSD 3-Clause License with Machine Learning Restriction
+
+Copyright (c) 2022, Northeastern University, Oberlin College, Roblox Inc,
+Stevens Institute of Technology, University of Massachusetts Amherst, and
+Wellesley College.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+4.  The contents of this repository may not be used as training data for any
+    machine learning model, including but not limited to neural networks.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Development.md

@@ -1,7 +1,7 @@
 # Development Guide
-This guide is for people working on OpenDevin and editing the source code.
-If you wish to contribute your changes, check out the [CONTRIBUTING.md](https://github.com/OpenDevin/OpenDevin/blob/main/CONTRIBUTING.md) on how to clone and setup the project initially before moving on.
-Otherwise, you can clone the OpenDevin project directly.
+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
@@ -29,14 +29,14 @@ 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 OpenDevin is ready to run on your system:
+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
 make build
 ```
 
 ### 3. Configuring the Language Model
-OpenDevin supports a diverse array of Language Models (LMs) through the powerful [litellm](https://docs.litellm.ai) library. By default, we've chosen the mighty GPT-4 from OpenAI as our go-to model, but the world is your oyster! You can unleash the potential of Anthropic's suave Claude, the enigmatic Llama, or any other LM that piques your interest.
+OpenHands supports a diverse array of Language Models (LMs) through the powerful [litellm](https://docs.litellm.ai) library. By default, we've chosen the mighty GPT-4 from OpenAI as our go-to model, but the world is your oyster! You can unleash the potential of Anthropic's suave Claude, the enigmatic Llama, or any other LM that piques your interest.
 
 To configure the LM of your choice, run:
 
@@ -44,20 +44,20 @@ To configure the LM of your choice, run:
    make setup-config
    ```
 
-   This command will prompt you to enter the LLM API key, model name, and other variables ensuring that OpenDevin 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 OpenDevin 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:
+   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:**
 Some alternative models may prove more challenging to tame than others. Fear not, brave adventurer! We shall soon unveil LLM-specific documentation to guide you on your quest.
-And if you've already mastered the art of wielding a model other than OpenAI's GPT, we encourage you to share your setup instructions with us by creating instructions and adding it [to our documentation](https://github.com/OpenDevin/OpenDevin/tree/main/docs/modules/usage/llms).
+And if you've already mastered the art of wielding a model other than OpenAI's GPT, we encourage you to share your setup instructions with us by creating instructions and adding it [to our documentation](https://github.com/All-Hands-AI/OpenHands/tree/main/docs/modules/usage/llms).
 
 For a full list of the LM providers and models available, please consult the [litellm documentation](https://docs.litellm.ai/docs/providers).
 
 ### 4. Running the application
 #### Option A: Run the Full Application
-Once the setup is complete, launching OpenDevin is as simple as running a single command. This command starts both the backend and frontend servers seamlessly, allowing you to interact with OpenDevin:
+Once the setup is complete, launching OpenHands is as simple as running a single command. This command starts both the backend and frontend servers seamlessly, allowing you to interact with OpenHands:
 ```bash
 make run
 ```
@@ -75,10 +75,10 @@ make run
 
 ### 6. LLM Debugging
 If you encounter any issues with the Language Model (LM) or you're simply curious, you can inspect the actual LLM prompts and responses. To do so, export DEBUG=1 in the environment and restart the backend.
-OpenDevin will then log the prompts and responses in the logs/llm/CURRENT_DATE directory, allowing you to identify the causes.
+OpenHands will then log the prompts and responses in the logs/llm/CURRENT_DATE directory, allowing you to identify the causes.
 
 ### 7. Help
-Need assistance or information on available targets and commands? The help command provides all the necessary guidance to ensure a smooth experience with OpenDevin.
+Need assistance or information on available targets and commands? The help command provides all the necessary guidance to ensure a smooth experience with OpenHands.
 ```bash
 make help
  ```
@@ -97,3 +97,28 @@ Please refer to [this README](./tests/integration/README.md) for details.
 ### 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`
+
+## Develop inside Docker container
+
+TL;DR
+
+```bash
+make docker-dev
+```
+
+See more details [here](./containers/dev/README.md)
+
+If you are just interested in running `OpenHands` without installing all the required tools on your host.
+
+```bash
+make docker-run
+```
+
+If you do not have `make` on your host, run:
+
+```bash
+cd ./containers/dev
+./dev.sh
+```
+
+You do need [Docker](https://docs.docker.com/engine/install/) installed on your host though.

MANIFEST.in

@@ -0,0 +1,5 @@
+# Exclude all Python bytecode files
+global-exclude *.pyc
+
+# Exclude Python cache directories
+global-exclude __pycache__

Makefile

@@ -1,10 +1,10 @@
 SHELL=/bin/bash
-# Makefile for OpenDevin project
+# Makefile for OpenHands project
 
 # Variables
-DOCKER_IMAGE = ghcr.io/opendevin/sandbox:main
+BACKEND_HOST ?= "127.0.0.1"
 BACKEND_PORT = 3000
-BACKEND_HOST = "127.0.0.1:$(BACKEND_PORT)"
+BACKEND_HOST_PORT = "$(BACKEND_HOST):$(BACKEND_PORT)"
 FRONTEND_PORT = 3001
 DEFAULT_WORKSPACE_DIR = "./workspace"
 DEFAULT_MODEL = "gpt-4o"
@@ -166,7 +166,7 @@ install-pre-commit-hooks:
 
 lint-backend:
 	@echo "$(YELLOW)Running linters...$(RESET)"
-	@poetry run pre-commit run --files opendevin/**/* agenthub/**/* evaluation/**/* --show-diff-on-failure --config $(PRE_COMMIT_CONFIG_PATH)
+	@poetry run pre-commit run --files openhands/**/* agenthub/**/* evaluation/**/* --show-diff-on-failure --config $(PRE_COMMIT_CONFIG_PATH)
 
 lint-frontend:
 	@echo "$(YELLOW)Running linters for frontend...$(RESET)"
@@ -190,12 +190,12 @@ build-frontend:
 # Start backend
 start-backend:
 	@echo "$(YELLOW)Starting backend...$(RESET)"
-	@poetry run uvicorn opendevin.server.listen:app --port $(BACKEND_PORT) --reload --reload-exclude "workspace/*"
+	@poetry run uvicorn openhands.server.listen:app --host $(BACKEND_HOST) --port $(BACKEND_PORT) --reload --reload-exclude "$(shell pwd)/workspace"
 
 # Start frontend
 start-frontend:
 	@echo "$(YELLOW)Starting frontend...$(RESET)"
-	@cd frontend && VITE_BACKEND_HOST=$(BACKEND_HOST) VITE_FRONTEND_PORT=$(FRONTEND_PORT) npm run start
+	@cd frontend && VITE_BACKEND_HOST=$(BACKEND_HOST_PORT) VITE_FRONTEND_PORT=$(FRONTEND_PORT) npm run start
 
 # Common setup for running the app (non-callable)
 _run_setup:
@@ -205,7 +205,7 @@ _run_setup:
 	fi
 	@mkdir -p logs
 	@echo "$(YELLOW)Starting backend server...$(RESET)"
-	@poetry run uvicorn opendevin.server.listen:app --port $(BACKEND_PORT) &
+	@poetry run uvicorn openhands.server.listen:app --host $(BACKEND_HOST) --port $(BACKEND_PORT) &
 	@echo "$(YELLOW)Waiting for the backend to start...$(RESET)"
 	@until nc -z localhost $(BACKEND_PORT); do sleep 0.1; done
 	@echo "$(GREEN)Backend started successfully.$(RESET)"
@@ -217,6 +217,20 @@ run:
 	@cd frontend && echo "$(BLUE)Starting frontend with npm...$(RESET)" && npm run start -- --port $(FRONTEND_PORT)
 	@echo "$(GREEN)Application started successfully.$(RESET)"
 
+# Run the app (in docker)
+docker-run: WORKSPACE_BASE ?= $(PWD)/workspace
+docker-run:
+	@if [ -f /.dockerenv ]; then \
+		echo "Running inside a Docker container. Exiting..."; \
+		exit 0; \
+	else \
+		echo "$(YELLOW)Running the app in Docker $(OPTIONS)...$(RESET)"; \
+		export WORKSPACE_BASE=${WORKSPACE_BASE}; \
+		export SANDBOX_USER_ID=$(shell id -u); \
+		export DATE=$(shell date +%Y%m%d%H%M%S); \
+		docker compose up $(OPTIONS); \
+	fi
+
 # Run the app (WSL mode)
 run-wsl:
 	@echo "$(YELLOW)Running the app in WSL mode...$(RESET)"
@@ -261,6 +275,10 @@ setup-config-prompts:
 		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; \
@@ -277,10 +295,20 @@ setup-config-prompts:
 		fi
 
 
+# Develop in container
+docker-dev:
+	@if [ -f /.dockerenv ]; then \
+		echo "Running inside a Docker container. Exiting..."; \
+		exit 0; \
+	else \
+		echo "$(YELLOW)Build and run in Docker $(OPTIONS)...$(RESET)"; \
+		./containers/dev/dev.sh $(OPTIONS); \
+	fi
+
 # Clean up all caches
 clean:
 	@echo "$(YELLOW)Cleaning up caches...$(RESET)"
-	@rm -rf opendevin/.cache
+	@rm -rf openhands/.cache
 	@echo "$(GREEN)Caches cleaned up successfully.$(RESET)"
 
 # Help
@@ -289,13 +317,16 @@ help:
 	@echo "Targets:"
 	@echo "  $(GREEN)build$(RESET)               - Build project, including environment setup and dependencies."
 	@echo "  $(GREEN)lint$(RESET)                - Run linters on the project."
-	@echo "  $(GREEN)setup-config$(RESET)        - Setup the configuration for OpenDevin by providing LLM API key,"
+	@echo "  $(GREEN)setup-config$(RESET)        - Setup the configuration for OpenHands by providing LLM API key,"
 	@echo "                        LLM Model name, and workspace directory."
-	@echo "  $(GREEN)start-backend$(RESET)       - Start the backend server for the OpenDevin project."
-	@echo "  $(GREEN)start-frontend$(RESET)      - Start the frontend server for the OpenDevin project."
-	@echo "  $(GREEN)run$(RESET)                 - Run the OpenDevin application, starting both backend and frontend servers."
+	@echo "  $(GREEN)start-backend$(RESET)       - Start the backend server for the OpenHands project."
+	@echo "  $(GREEN)start-frontend$(RESET)      - Start the frontend server for the OpenHands project."
+	@echo "  $(GREEN)run$(RESET)                 - Run the OpenHands application, starting both backend and frontend servers."
 	@echo "                        Backend Log file will be stored in the 'logs' directory."
+	@echo "  $(GREEN)docker-dev$(RESET)          - Build and run the OpenHands application in Docker."
+	@echo "  $(GREEN)docker-run$(RESET)          - Run the OpenHands application, starting both backend and frontend servers in Docker."
 	@echo "  $(GREEN)help$(RESET)                - Display this help message, providing information on available targets."
 
 # Phony targets
 .PHONY: build check-dependencies check-python check-npm check-docker check-poetry install-python-dependencies install-frontend-dependencies install-pre-commit-hooks lint start-backend start-frontend run run-wsl setup-config setup-config-prompts help
+.PHONY: docker-dev docker-run

README.md

@@ -1,124 +1,103 @@
 <a name="readme-top"></a>
 
-<!--
-*** Thanks for checking out the Best-README-Template. If you have a suggestion
-*** that would make this better, please fork the repo and create a pull request
-*** or simply open an issue with the tag "enhancement".
-*** Don't forget to give the project a star!
-*** Thanks again! Now go create something AMAZING! :D
--->
+<div align="center">
+  <img src="./docs/static/img/logo.png" alt="Logo" width="200">
+  <h1 align="center">OpenHands: Code Less, Make More</h1>
+</div>
 
-<!-- PROJECT SHIELDS -->
-<!--
-*** I'm using markdown "reference style" links for readability.
-*** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
-*** See the bottom of this document for the declaration of the reference variables
-*** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
-*** https://www.markdownguide.org/basic-syntax/#reference-style-links
--->
 
 <div align="center">
-  <a href="https://github.com/OpenDevin/OpenDevin/graphs/contributors"><img src="https://img.shields.io/github/contributors/opendevin/opendevin?style=for-the-badge&color=blue" alt="Contributors"></a>
-  <a href="https://github.com/OpenDevin/OpenDevin/network/members"><img src="https://img.shields.io/github/forks/opendevin/opendevin?style=for-the-badge&color=blue" alt="Forks"></a>
-  <a href="https://github.com/OpenDevin/OpenDevin/stargazers"><img src="https://img.shields.io/github/stars/opendevin/opendevin?style=for-the-badge&color=blue" alt="Stargazers"></a>
-  <a href="https://github.com/OpenDevin/OpenDevin/issues"><img src="https://img.shields.io/github/issues/opendevin/opendevin?style=for-the-badge&color=blue" alt="Issues"></a>
-  <a href="https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE"><img src="https://img.shields.io/github/license/opendevin/opendevin?style=for-the-badge&color=blue" alt="MIT License"></a>
+  <a href="https://github.com/All-Hands-AI/OpenHands/graphs/contributors"><img src="https://img.shields.io/github/contributors/All-Hands-AI/OpenHands?style=for-the-badge&color=blue" alt="Contributors"></a>
+  <a href="https://github.com/All-Hands-AI/OpenHands/stargazers"><img src="https://img.shields.io/github/stars/All-Hands-AI/OpenHands?style=for-the-badge&color=blue" alt="Stargazers"></a>
+  <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/opendevin/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://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA"><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://codecov.io/github/opendevin/opendevin?branch=main"><img alt="CodeCov" src="https://img.shields.io/codecov/c/github/opendevin/opendevin?style=for-the-badge"></a>
-</div>
-
-<!-- PROJECT LOGO -->
-<div align="center">
-  <img src="./docs/static/img/logo.png" alt="Logo" width="200" height="200">
-  <h1 align="center">OpenDevin: Code Less, Make More</h1>
-  <a href="https://docs.all-hands.dev/modules/usage/intro"><img src="https://img.shields.io/badge/Documentation-OpenDevin-blue?logo=googledocs&logoColor=white&style=for-the-badge" alt="Check out the documentation"></a>
-  <a href="https://arxiv.org/abs/2407.16741"><img src="https://img.shields.io/badge/Paper-%20on%20Arxiv-red?logo=arxiv&style=for-the-badge" alt="Paper on Arxiv"></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/>
-  <a href="https://huggingface.co/spaces/OpenDevin/evaluation"><img src="https://img.shields.io/badge/Evaluation-Benchmark%20on%20HF%20Space-green?logo=huggingface&style=for-the-badge" alt="Evaluation Benchmark"></a>
+  <a href="https://docs.all-hands.dev/modules/usage/getting-started"><img src="https://img.shields.io/badge/Documentation-000?logo=googledocs&logoColor=FFE165&style=for-the-badge" alt="Check out the documentation"></a>
+  <a href="https://arxiv.org/abs/2407.16741"><img src="https://img.shields.io/badge/Paper%20on%20Arxiv-000?logoColor=FFE165&logo=arxiv&style=for-the-badge" alt="Paper on Arxiv"></a>
+  <a href="https://huggingface.co/spaces/OpenHands/evaluation"><img src="https://img.shields.io/badge/Benchmark%20score-000?logoColor=FFE165&logo=huggingface&style=for-the-badge" alt="Evaluation Benchmark Score"></a>
+  <hr>
 </div>
-<hr>
 
-Welcome to OpenDevin, a platform for autonomous software engineers, powered by AI and LLMs.
+Welcome to OpenHands (formerly OpenDevin), a platform for software development agents powered by AI.
 
-OpenDevin agents collaborate with human developers to write code, fix bugs, and ship features.
+OpenHands agents can do anything a human developer can: modify code, run commands, browse the web,
+call APIs, and yes—even copy code snippets from StackOverflow.
+
+Learn more at [docs.all-hands.dev](https://docs.all-hands.dev), or jump to the [Quick Start](#-quick-start).
 
 ![App screenshot](./docs/static/img/screenshot.png)
 
-## ⚡ Getting Started
-OpenDevin works best with Docker version 26.0.0+ (Docker Desktop 4.31.0+).
-You must be using Linux, Mac OS, or WSL on Windows.
+## ⚡ Quick Start
 
-To start OpenDevin in a docker container, run the following commands in your terminal:
+The easiest way to run OpenHands is in Docker. You can change `WORKSPACE_BASE` below to
+point OpenHands to existing code that you'd like to modify.
 
-> [!WARNING]
-> When you run the following command, files in `./workspace` may be modified or deleted.
+See the [Getting Started](https://docs.all-hands.dev/modules/usage/getting-started) guide for
+system requirements and more information.
 
 ```bash
-WORKSPACE_BASE=$(pwd)/workspace
-docker run -it \
-    --pull=always \
+export WORKSPACE_BASE=$(pwd)/workspace
+
+docker run -it --pull=always \
+    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=ghcr.io/all-hands-ai/runtime:0.9-nikolaik \
     -e SANDBOX_USER_ID=$(id -u) \
     -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \
     -v $WORKSPACE_BASE:/opt/workspace_base \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
-    --name opendevin-app-$(date +%Y%m%d%H%M%S) \
-    ghcr.io/opendevin/opendevin:0.8
+    --name openhands-app-$(date +%Y%m%d%H%M%S) \
+    ghcr.io/all-hands-ai/openhands:0.9
 ```
 
-> [!NOTE]
-> By default, this command pulls the `latest` tag, which represents the most recent release of OpenDevin. You have other options as well:
-> - For a specific release version, use `ghcr.io/opendevin/opendevin:<OpenDevin_version>` (replace <OpenDevin_version> with the desired version number).
-> - For the most up-to-date development version, use `ghcr.io/opendevin/opendevin:main`. This version may be **(unstable!)** and is recommended for testing or development purposes only.
->
-> Choose the tag that best suits your needs based on stability requirements and desired features.
+You'll find OpenHands running at [http://localhost:3000](http://localhost:3000)!
 
-You'll find OpenDevin running at [http://localhost:3000](http://localhost:3000) with access to `./workspace`. To have OpenDevin operate on your code, place it in `./workspace`.
-OpenDevin will only have access to this workspace folder. The rest of your system will not be affected as it runs in a secured docker sandbox.
+You can also run OpenHands in a scriptable [headless mode](https://docs.all-hands.dev/modules/usage/how-to/headless-mode),
+or as an [interactive CLI](https://docs.all-hands.dev/modules/usage/how-to/cli-mode).
 
-Upon opening OpenDevin, you must select the appropriate `Model` and enter the `API Key` within the settings that should pop up automatically. These can be set at any time by selecting
-the `Settings` button (gear icon) in the UI. If the required `Model` does not exist in the list, you can manually enter it in the text box.
+Visit [Getting Started](https://docs.all-hands.dev/modules/usage/getting-started) for more information and setup instructions.
 
-For the development workflow, see [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md).
+If you want to modify the OpenHands source code, check out [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
 
-Are you having trouble? Check out our [Troubleshooting Guide](https://docs.all-hands.dev/modules/usage/troubleshooting).
+Having issues? The [Troubleshooting Guide](https://docs.all-hands.dev/modules/usage/troubleshooting) can help.
 
-## 🚀 Documentation
+## 📖 Documentation
 
-To learn more about the project, and for tips on using OpenDevin,
-**check out our [documentation](https://docs.all-hands.dev/modules/usage/intro)**.
+To learn more about the project, and for tips on using OpenHands,
+**check out our [documentation](https://docs.all-hands.dev/modules/usage/getting-started)**.
 
-There you'll find resources on how to use different LLM providers (like ollama and Anthropic's Claude),
+There you'll find resources on how to use different LLM providers,
 troubleshooting resources, and advanced configuration options.
 
 ## 🤝 How to Contribute
 
-OpenDevin is a community-driven project, and we welcome contributions from everyone.
+OpenHands is a community-driven project, and we welcome contributions from everyone.
 Whether you're a developer, a researcher, or simply enthusiastic about advancing the field of
 software engineering with AI, there are many ways to get involved:
 
 - **Code Contributions:** Help us develop new agents, core functionality, the frontend and other interfaces, or sandboxing solutions.
 - **Research and Evaluation:** Contribute to our understanding of LLMs in software engineering, participate in evaluating the models, or suggest improvements.
-- **Feedback and Testing:** Use the OpenDevin toolset, report bugs, suggest features, or provide feedback on usability.
+- **Feedback and Testing:** Use the OpenHands toolset, report bugs, suggest features, or provide feedback on usability.
 
 For details, please check [CONTRIBUTING.md](./CONTRIBUTING.md).
 
 ## 🤖 Join Our Community
 
-Whether you're a developer, a researcher, or simply enthusiastic about OpenDevin, we'd love to have you in our community.
+Whether you're a developer, a researcher, or simply enthusiastic about OpenHands, we'd love to have you in our community.
 Let's make software engineering better together!
 
-- [Slack workspace](https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw) - Here we talk about research, architecture, and future development.
+- [Slack workspace](https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA) - Here we talk about research, architecture, and future development.
 - [Discord server](https://discord.gg/ESHStjSjD4) - This is a community-run server for general discussion, questions, and feedback.
 
 ## 📈 Progress
 
 <p align="center">
-  <a href="https://star-history.com/#OpenDevin/OpenDevin&Date">
-    <img src="https://api.star-history.com/svg?repos=OpenDevin/OpenDevin&type=Date" width="500" alt="Star History Chart">
+  <a href="https://star-history.com/#All-Hands-AI/OpenHands&Date">
+    <img src="https://api.star-history.com/svg?repos=All-Hands-AI/OpenHands&type=Date" width="500" alt="Star History Chart">
   </a>
 </p>
 
@@ -126,16 +105,11 @@ Let's make software engineering better together!
 
 Distributed under the MIT License. See [`LICENSE`](./LICENSE) for more information.
 
-[contributors-shield]: https://img.shields.io/github/contributors/opendevin/opendevin?style=for-the-badge
-[contributors-url]: https://github.com/OpenDevin/OpenDevin/graphs/contributors
-[forks-shield]: https://img.shields.io/github/forks/opendevin/opendevin?style=for-the-badge
-[forks-url]: https://github.com/OpenDevin/OpenDevin/network/members
-[stars-shield]: https://img.shields.io/github/stars/opendevin/opendevin?style=for-the-badge
-[stars-url]: https://github.com/OpenDevin/OpenDevin/stargazers
-[issues-shield]: https://img.shields.io/github/issues/opendevin/opendevin?style=for-the-badge
-[issues-url]: https://github.com/OpenDevin/OpenDevin/issues
-[license-shield]: https://img.shields.io/github/license/opendevin/opendevin?style=for-the-badge
-[license-url]: https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE
+## 🙏 Acknowledgements
+
+OpenHands is built by a large number of contributors, and every contribution is greatly appreciated! We also build upon other open source projects, and we are deeply thankful for their work.
+
+For a list of open source projects and licenses used in OpenHands, please see our [CREDITS.md](./CREDITS.md) file.
 
 ## 📚 Cite
 

agenthub/README.md

@@ -7,40 +7,61 @@ Contributors from different backgrounds and interests can choose to contribute t
 
 ## Constructing an Agent
 
-The abstraction for an agent can be found [here](../opendevin/controller/agent.py).
+The abstraction for an agent can be found [here](../openhands/controller/agent.py).
 
 Agents are run inside of a loop. At each iteration, `agent.step()` is called with a
-[State](../opendevin/controller/state/state.py) input, and the agent must output an [Action](../opendevin/events/action).
+[State](../openhands/controller/state/state.py) input, and the agent must output an [Action](../openhands/events/action).
 
 Every agent also has a `self.llm` which it can use to interact with the LLM configured by the user.
 See the [LiteLLM docs for `self.llm.completion`](https://docs.litellm.ai/docs/completion).
 
 ## State
 
-The `state` contains:
+The `state` represents the running state of an agent in the OpenHands system. The class handles saving and restoring the agent session. It is serialized in a pickle.
 
-- A history of actions taken by the agent, as well as any observations (e.g. file content, command output) from those actions
-- A list of actions/observations that have happened since the most recent step
-- A [`root_task`](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/controller/state/task.py), which contains a plan of action
-  - The agent can add and modify subtasks through the `AddTaskAction` and `ModifyTaskAction`
+The State object stores information about:
+
+* Multi-agent state / delegates:
+  * the 'root task' (conversation between the agent and the user)
+  * the subtask (conversation between an agent and the user or another agent)
+  * global and local iterations
+  * delegate levels for multi-agent interactions
+  * almost stuck state
+* Running state of an agent:
+  * current agent state (e.g., LOADING, RUNNING, PAUSED)
+  * traffic control state for rate limiting
+  * confirmation mode
+  * the last error encountered
+* History:
+  * start and end IDs for events in agent's history. This allows to retrieve the actions taken by the agent, and observations (e.g. file content, command output) from the current or past sessions.
+* Metrics:
+  * global metrics for the current task
+  * local metrics for the current subtask
+* Extra data:
+  * additional task-specific data
+
+The agent can add and modify subtasks through the `AddTaskAction` and `ModifyTaskAction`
 
 ## Actions
 
 Here is a list of available Actions, which can be returned by `agent.step()`:
 
-- [`CmdRunAction`](../opendevin/events/action/commands.py) - Runs a command inside a sandboxed terminal
-- [`IPythonRunCellAction`](../opendevin/events/action/commands.py) - Execute a block of Python code interactively (in Jupyter notebook) and receives `CmdOutputObservation`. Requires setting up `jupyter` [plugin](../opendevin/runtime/plugins) as a requirement.
-- [`FileReadAction`](../opendevin/events/action/files.py) - Reads the content of a file
-- [`FileWriteAction`](../opendevin/events/action/files.py) - Writes new content to a file
-- [`BrowseURLAction`](../opendevin/events/action/browse.py) - Gets the content of a URL
-- [`AddTaskAction`](../opendevin/events/action/tasks.py) - Adds a subtask to the plan
-- [`ModifyTaskAction`](../opendevin/events/action/tasks.py) - Changes the state of a subtask.
-- [`AgentFinishAction`](../opendevin/events/action/agent.py) - Stops the control loop, allowing the user/delegator agent to enter a new task
-- [`AgentRejectAction`](../opendevin/events/action/agent.py) - Stops the control loop, allowing the user/delegator agent to enter a new task
-- [`AgentFinishAction`](../opendevin/events/action/agent.py) - Stops the control loop, allowing the user to enter a new task
-- [`MessageAction`](../opendevin/events/action/message.py) - Represents a message from an agent or the user
+- [`CmdRunAction`](../openhands/events/action/commands.py) - Runs a command inside a sandboxed terminal
+- [`IPythonRunCellAction`](../openhands/events/action/commands.py) - Execute a block of Python code interactively (in Jupyter notebook) and receives `CmdOutputObservation`. Requires setting up `jupyter` [plugin](../openhands/runtime/plugins) as a requirement.
+- [`FileReadAction`](../openhands/events/action/files.py) - Reads the content of a file
+- [`FileWriteAction`](../openhands/events/action/files.py) - Writes new content to a file
+- [`BrowseURLAction`](../openhands/events/action/browse.py) - Gets the content of a URL
+- [`AddTaskAction`](../openhands/events/action/tasks.py) - Adds a subtask to the plan
+- [`ModifyTaskAction`](../openhands/events/action/tasks.py) - Changes the state of a subtask.
+- [`AgentFinishAction`](../openhands/events/action/agent.py) - Stops the control loop, allowing the user/delegator agent to enter a new task
+- [`AgentRejectAction`](../openhands/events/action/agent.py) - Stops the control loop, allowing the user/delegator agent to enter a new task
+- [`AgentFinishAction`](../openhands/events/action/agent.py) - Stops the control loop, allowing the user to enter a new task
+- [`MessageAction`](../openhands/events/action/message.py) - Represents a message from an agent or the user
 
-You can use `action.to_dict()` and `action_from_dict` to serialize and deserialize actions.
+To serialize and deserialize an action, you can use:
+- `action.to_dict()` to serialize the action to a dictionary to be sent to the UI, including a user-friendly string representation of the message
+- `action.to_memory()` to serialize the action to a dictionary to be sent to the LLM. It may include raw information, such as the underlying exceptions that occurred during the action execution.
+- `action_from_dict(action_dict)` to deserialize the action from a dictionary.
 
 ## Observations
 
@@ -49,12 +70,12 @@ But they may also appear as a result of asynchronous events (e.g. a message from
 
 Here is a list of available Observations:
 
-- [`CmdOutputObservation`](../opendevin/events/observation/commands.py)
-- [`BrowserOutputObservation`](../opendevin/events/observation/browse.py)
-- [`FileReadObservation`](../opendevin/events/observation/files.py)
-- [`FileWriteObservation`](../opendevin/events/observation/files.py)
-- [`ErrorObservation`](../opendevin/events/observation/error.py)
-- [`SuccessObservation`](../opendevin/events/observation/success.py)
+- [`CmdOutputObservation`](../openhands/events/observation/commands.py)
+- [`BrowserOutputObservation`](../openhands/events/observation/browse.py)
+- [`FileReadObservation`](../openhands/events/observation/files.py)
+- [`FileWriteObservation`](../openhands/events/observation/files.py)
+- [`ErrorObservation`](../openhands/events/observation/error.py)
+- [`SuccessObservation`](../openhands/events/observation/success.py)
 
 You can use `observation.to_dict()` and `observation_from_dict` to serialize and deserialize observations.
 
@@ -70,3 +91,52 @@ def step(self, state: "State") -> "Action"
 
 `step` moves the agent forward one step towards its goal. This probably means
 sending a prompt to the LLM, then parsing the response into an `Action`.
+
+## Agent Delegation
+
+OpenHands is a multi-agentic system. Agents can delegate tasks to other agents, whether
+prompted by the user, or when the agent decides to ask another agent for help. For example,
+the `CodeActAgent` might delegate to the `BrowsingAgent` to answer questions that involve browsing
+the web. The Delegator Agent forwards tasks to micro-agents, such as 'RepoStudyAgent' to study a repo,
+or 'VerifierAgent' to verify a task completion.
+
+### Understanding the terminology
+
+A `task` is an end-to-end conversation between OpenHands (the whole system) and the user,
+which might involve one or more inputs from the user. It starts with an initial input
+(typically a task statement) from the user, and ends with either an `AgentFinishAction`
+initiated by the agent, a stop initiated by the user, or an error.
+
+A `subtask` is an end-to-end conversation between an agent and the user, or
+another agent. If a `task` is conducted by a single agent, then it's also a `subtask`
+itself. Otherwise, a `task` consists of multiple `subtasks`, each executed by
+one agent.
+
+For example, considering a task from the user: `tell me how many GitHub stars
+OpenHands repo has`. Let's assume the default agent is CodeActAgent.
+
+```
+-- TASK STARTS (SUBTASK 0 STARTS) --
+
+DELEGATE_LEVEL 0, ITERATION 0, LOCAL_ITERATION 0
+CodeActAgent: I should request help from BrowsingAgent
+
+-- DELEGATE STARTS (SUBTASK 1 STARTS) --
+
+DELEGATE_LEVEL 1, ITERATION 1, LOCAL_ITERATION 0
+BrowsingAgent: Let me find the answer on GitHub
+
+DELEGATE_LEVEL 1, ITERATION 2, LOCAL_ITERATION 1
+BrowsingAgent: I found the answer, let me convey the result and finish
+
+-- DELEGATE ENDS (SUBTASK 1 ENDS) --
+
+DELEGATE_LEVEL 0, ITERATION 3, LOCAL_ITERATION 1
+CodeActAgent: I got the answer from BrowsingAgent, let me convey the result
+and finish
+
+-- TASK ENDS (SUBTASK 0 ENDS) --
+```
+
+Note how ITERATION counter is shared across agents, while LOCAL_ITERATION
+is local to each subtask.

agenthub/__init__.py

@@ -1,14 +1,13 @@
 from dotenv import load_dotenv
 
-from opendevin.controller.agent import Agent
-
-from .micro.agent import MicroAgent
-from .micro.registry import all_microagents
+from agenthub.micro.agent import MicroAgent
+from agenthub.micro.registry import all_microagents
+from openhands.controller.agent import Agent
 
 load_dotenv()
 
 
-from . import (  # noqa: E402
+from agenthub import (  # noqa: E402
     browsing_agent,
     codeact_agent,
     codeact_swe_agent,

agenthub/browsing_agent/README.md

@@ -8,7 +8,7 @@ This folder implements the basic BrowserGym [demo agent](https://github.com/Serv
 Note that for browsing tasks, GPT-4 is usually a requirement to get reasonable results, due to the complexity of the web page structures.
 
 ```
-poetry run python ./opendevin/core/main.py \
+poetry run python ./openhands/core/main.py \
            -i 10 \
            -t "tell me the usa's president using google search" \
            -c BrowsingAgent \

agenthub/browsing_agent/__init__.py

@@ -1,5 +1,4 @@
-from opendevin.controller.agent import Agent
-
-from .browsing_agent import BrowsingAgent
+from agenthub.browsing_agent.browsing_agent import BrowsingAgent
+from openhands.controller.agent import Agent
 
 Agent.register('BrowsingAgent', BrowsingAgent)

agenthub/browsing_agent/browsing_agent.py

@@ -4,24 +4,24 @@ from browsergym.core.action.highlevel import HighLevelActionSet
 from browsergym.utils.obs import flatten_axtree_to_str
 
 from agenthub.browsing_agent.response_parser import BrowsingResponseParser
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.core.logger import opendevin_logger as logger
-from opendevin.core.message import Message, TextContent
-from opendevin.events.action import (
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.core.logger import openhands_logger as logger
+from openhands.core.message import Message, TextContent
+from openhands.events.action import (
     Action,
     AgentFinishAction,
     BrowseInteractiveAction,
     MessageAction,
 )
-from opendevin.events.event import EventSource
-from opendevin.events.observation import BrowserOutputObservation
-from opendevin.events.observation.observation import Observation
-from opendevin.llm.llm import LLM
-from opendevin.runtime.plugins import (
+from openhands.events.event import EventSource
+from openhands.events.observation import BrowserOutputObservation
+from openhands.events.observation.observation import Observation
+from openhands.llm.llm import LLM
+from openhands.runtime.plugins import (
     PluginRequirement,
 )
-from opendevin.runtime.tools import RuntimeTool
 
 USE_NAV = (
     os.environ.get('USE_NAV', 'true') == 'true'
@@ -65,10 +65,15 @@ In order to accomplish my goal I need to send the information asked back to the
 """
 
 
-def get_prompt(error_prefix: str, cur_axtree_txt: str, prev_action_str: str) -> str:
+def get_prompt(
+    error_prefix: str, cur_url: str, cur_axtree_txt: str, prev_action_str: str
+) -> str:
     prompt = f"""\
 {error_prefix}
 
+# Current Page URL:
+{cur_url}
+
 # Current Accessibility Tree:
 {cur_axtree_txt}
 
@@ -93,19 +98,19 @@ class BrowsingAgent(Agent):
     """
 
     sandbox_plugins: list[PluginRequirement] = []
-    runtime_tools: list[RuntimeTool] = [RuntimeTool.BROWSER]
     response_parser = BrowsingResponseParser()
 
     def __init__(
         self,
         llm: LLM,
+        config: AgentConfig,
     ) -> None:
         """Initializes a new instance of the BrowsingAgent class.
 
         Parameters:
         - llm (LLM): The llm to be used by this agent
         """
-        super().__init__(llm)
+        super().__init__(llm, config)
         # define a configurable action space, with chat functionality, web navigation, and webpage grounding using accessibility tree and HTML.
         # see https://github.com/ServiceNow/BrowserGym/blob/main/core/src/browsergym/core/action/highlevel.py for more details
         action_subsets = ['chat', 'bid']
@@ -139,6 +144,7 @@ class BrowsingAgent(Agent):
         """
         messages: list[Message] = []
         prev_actions = []
+        cur_url = ''
         cur_axtree_txt = ''
         error_prefix = ''
         last_obs = None
@@ -165,7 +171,7 @@ class BrowsingAgent(Agent):
 
         prev_action_str = '\n'.join(prev_actions)
         # if the final BrowserInteractiveAction exec BrowserGym's send_msg_to_user,
-        # we should also send a message back to the user in OpenDevin and call it a day
+        # we should also send a message back to the user in OpenHands and call it a day
         if (
             isinstance(last_action, BrowseInteractiveAction)
             and last_action.browsergym_send_msg_to_user
@@ -179,6 +185,9 @@ class BrowsingAgent(Agent):
                 self.error_accumulator += 1
                 if self.error_accumulator > 5:
                     return MessageAction('Too many errors encountered. Task failed.')
+
+            cur_url = last_obs.url
+
             try:
                 cur_axtree_txt = flatten_axtree_to_str(
                     last_obs.axtree_object,
@@ -204,11 +213,11 @@ class BrowsingAgent(Agent):
 
         messages.append(Message(role='system', content=[TextContent(text=system_msg)]))
 
-        prompt = get_prompt(error_prefix, cur_axtree_txt, prev_action_str)
+        prompt = get_prompt(error_prefix, cur_url, cur_axtree_txt, prev_action_str)
         messages.append(Message(role='user', content=[TextContent(text=prompt)]))
-        logger.debug(prompt)
+
         response = self.llm.completion(
-            messages=[message.model_dump() for message in messages],
+            messages=self.llm.format_messages_for_llm(messages),
             temperature=0.0,
             stop=[')```', ')\n```'],
         )

agenthub/browsing_agent/prompt.py

@@ -12,12 +12,11 @@ from browsergym.core.action.base import AbstractActionSet
 from browsergym.core.action.highlevel import HighLevelActionSet
 from browsergym.core.action.python import PythonActionSet
 
-from opendevin.runtime.browser.browser_env import BrowserEnv
-
-from .utils import (
+from agenthub.browsing_agent.utils import (
     ParseError,
     parse_html_tags_raise,
 )
+from openhands.runtime.browser.browser_env import BrowserEnv
 
 
 @dataclass
@@ -58,7 +57,7 @@ class Flags:
 
     @classmethod
     def from_dict(self, flags_dict):
-        """Helper for JSON serializble requirement."""
+        """Helper for JSON serializable requirement."""
         if isinstance(flags_dict, Flags):
             return flags_dict
 
@@ -355,7 +354,7 @@ and executed by a program, make sure to follow the formatting instructions.
         self._prompt += '\n'.join(
             [
                 f"""\
- - [{msg['role']}] {msg['message']}"""
+ - [{msg['role']}], {msg['message']}"""
                 for msg in chat_messages
             ]
         )

agenthub/browsing_agent/response_parser.py

@@ -1,8 +1,8 @@
 import ast
 
-from opendevin.controller.action_parser import ActionParser, ResponseParser
-from opendevin.core.logger import opendevin_logger as logger
-from opendevin.events.action import (
+from openhands.controller.action_parser import ActionParser, ResponseParser
+from openhands.core.logger import openhands_logger as logger
+from openhands.events.action import (
     Action,
     BrowseInteractiveAction,
 )
@@ -24,9 +24,9 @@ class BrowsingResponseParser(ResponseParser):
         if action_str is None:
             return ''
         action_str = action_str.strip()
-        if not action_str.endswith('```'):
+        if action_str and not action_str.endswith('```'):
             action_str = action_str + ')```'
-        logger.info(action_str)
+        logger.debug(action_str)
         return action_str
 
     def parse_action(self, action_str: str) -> Action:

agenthub/codeact_agent/README.md

@@ -9,21 +9,4 @@ The conceptual idea is illustrated below. At each turn, the agent can:
    - Execute any valid Linux `bash` command
    - Execute any valid `Python` code with [an interactive Python interpreter](https://ipython.org/). This is simulated through `bash` command, see plugin system below for more details.
 
-![image](https://github.com/OpenDevin/OpenDevin/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
-
-## Plugin System
-
-To make the CodeAct agent more powerful with only access to `bash` action space, CodeAct agent leverages OpenDevin's plugin system:
-- [Jupyter plugin](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/jupyter): for IPython execution via bash command
-- [SWE-agent tool plugin](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/swe_agent_commands): Powerful bash command line tools for software development tasks introduced by [swe-agent](https://github.com/princeton-nlp/swe-agent).
-
-## Demo
-
-https://github.com/OpenDevin/OpenDevin/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
-
-*Example of CodeActAgent with `gpt-4-turbo-2024-04-09` performing a data science task (linear regression)*
-
-## Work-in-progress & Next step
-
-[] Support web-browsing
-[] Complete the workflow for CodeAct agent to submit Github PRs
+![image](https://github.com/All-Hands-AI/OpenHands/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)

agenthub/codeact_agent/__init__.py

@@ -1,5 +1,4 @@
-from opendevin.controller.agent import Agent
-
-from .codeact_agent import CodeActAgent
+from agenthub.codeact_agent.codeact_agent import CodeActAgent
+from openhands.controller.agent import Agent
 
 Agent.register('CodeActAgent', CodeActAgent)

agenthub/codeact_agent/action_parser.py

@@ -1,7 +1,7 @@
 import re
 
-from opendevin.controller.action_parser import ActionParser, ResponseParser
-from opendevin.events.action import (
+from openhands.controller.action_parser import ActionParser, ResponseParser
+from openhands.events.action import (
     Action,
     AgentDelegateAction,
     AgentFinishAction,

agenthub/codeact_agent/codeact_agent.py

@@ -1,15 +1,12 @@
+import os
+from itertools import islice
+
 from agenthub.codeact_agent.action_parser import CodeActResponseParser
-from agenthub.codeact_agent.prompt import (
-    COMMAND_DOCS,
-    EXAMPLES,
-    GITHUB_MESSAGE,
-    SYSTEM_PREFIX,
-    SYSTEM_SUFFIX,
-)
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.core.message import ImageContent, Message, TextContent
-from opendevin.events.action import (
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.core.message import ImageContent, Message, TextContent
+from openhands.events.action import (
     Action,
     AgentDelegateAction,
     AgentFinishAction,
@@ -17,38 +14,27 @@ from opendevin.events.action import (
     IPythonRunCellAction,
     MessageAction,
 )
-from opendevin.events.observation import (
+from openhands.events.observation import (
     AgentDelegateObservation,
     CmdOutputObservation,
     IPythonRunCellObservation,
+    UserRejectObservation,
 )
-from opendevin.events.observation.observation import Observation
-from opendevin.events.serialization.event import truncate_content
-from opendevin.llm.llm import LLM
-from opendevin.runtime.plugins import (
+from openhands.events.observation.error import ErrorObservation
+from openhands.events.observation.observation import Observation
+from openhands.events.serialization.event import truncate_content
+from openhands.llm.llm import LLM
+from openhands.runtime.plugins import (
     AgentSkillsRequirement,
     JupyterRequirement,
     PluginRequirement,
 )
-from opendevin.runtime.tools import RuntimeTool
-
-ENABLE_GITHUB = True
-
-
-# FIXME: We can tweak these two settings to create MicroAgents specialized toward different area
-def get_system_message() -> str:
-    if ENABLE_GITHUB:
-        return f'{SYSTEM_PREFIX}\n{GITHUB_MESSAGE}\n\n{COMMAND_DOCS}\n\n{SYSTEM_SUFFIX}'
-    else:
-        return f'{SYSTEM_PREFIX}\n\n{COMMAND_DOCS}\n\n{SYSTEM_SUFFIX}'
-
-
-def get_in_context_example() -> str:
-    return EXAMPLES
+from openhands.utils.microagent import MicroAgent
+from openhands.utils.prompt import PromptManager
 
 
 class CodeActAgent(Agent):
-    VERSION = '1.8'
+    VERSION = '1.9'
     """
     The Code Act Agent is a minimalist agent.
     The agent works by passing the model a list of action-observation pairs and prompting the model to take the next step.
@@ -64,24 +50,7 @@ class CodeActAgent(Agent):
     - Execute any valid Linux `bash` command
     - Execute any valid `Python` code with [an interactive Python interpreter](https://ipython.org/). This is simulated through `bash` command, see plugin system below for more details.
 
-    ![image](https://github.com/OpenDevin/OpenDevin/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
-
-    ### Plugin System
-
-    To make the CodeAct agent more powerful with only access to `bash` action space, CodeAct agent leverages OpenDevin's plugin system:
-    - [Jupyter plugin](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/jupyter): for IPython execution via bash command
-    - [SWE-agent tool plugin](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/swe_agent_commands): Powerful bash command line tools for software development tasks introduced by [swe-agent](https://github.com/princeton-nlp/swe-agent).
-
-    ### Demo
-
-    https://github.com/OpenDevin/OpenDevin/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
-
-    *Example of CodeActAgent with `gpt-4-turbo-2024-04-09` performing a data science task (linear regression)*
-
-    ### Work-in-progress & Next step
-
-    [] Support web-browsing
-    [] Complete the workflow for CodeAct agent to submit Github PRs
+    ![image](https://github.com/All-Hands-AI/OpenHands/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
 
     """
 
@@ -92,25 +61,38 @@ class CodeActAgent(Agent):
         AgentSkillsRequirement(),
         JupyterRequirement(),
     ]
-    runtime_tools: list[RuntimeTool] = [RuntimeTool.BROWSER]
-
-    system_message: str = get_system_message()
-    in_context_example: str = f"Here is an example of how you can interact with the environment for task solving:\n{get_in_context_example()}\n\nNOW, LET'S START!"
 
     action_parser = CodeActResponseParser()
 
     def __init__(
         self,
         llm: LLM,
+        config: AgentConfig,
     ) -> None:
         """Initializes a new instance of the CodeActAgent class.
 
         Parameters:
         - llm (LLM): The llm to be used by this agent
         """
-        super().__init__(llm)
+        super().__init__(llm, config)
         self.reset()
 
+        self.micro_agent = (
+            MicroAgent(
+                os.path.join(
+                    os.path.dirname(__file__), 'micro', f'{config.micro_agent_name}.md'
+                )
+            )
+            if config.micro_agent_name
+            else None
+        )
+
+        self.prompt_manager = PromptManager(
+            prompt_dir=os.path.join(os.path.dirname(__file__)),
+            agent_skills_docs=AgentSkillsRequirement.documentation,
+            micro_agent=self.micro_agent,
+        )
+
     def action_to_str(self, action: Action) -> str:
         if isinstance(action, CmdRunAction):
             return (
@@ -136,7 +118,11 @@ class CodeActAgent(Agent):
         ):
             content = [TextContent(text=self.action_to_str(action))]
 
-            if isinstance(action, MessageAction) and action.images_urls:
+            if (
+                self.llm.vision_is_active()
+                and isinstance(action, MessageAction)
+                and action.images_urls
+            ):
                 content.append(ImageContent(image_urls=action.images_urls))
 
             return Message(
@@ -146,14 +132,15 @@ class CodeActAgent(Agent):
 
     def get_observation_message(self, obs: Observation) -> Message | None:
         max_message_chars = self.llm.config.max_message_chars
+        obs_prefix = 'OBSERVATION:\n'
         if isinstance(obs, CmdOutputObservation):
-            text = 'OBSERVATION:\n' + truncate_content(obs.content, max_message_chars)
+            text = obs_prefix + truncate_content(obs.content, max_message_chars)
             text += (
                 f'\n[Command {obs.command_id} finished with exit code {obs.exit_code}]'
             )
             return Message(role='user', content=[TextContent(text=text)])
         elif isinstance(obs, IPythonRunCellObservation):
-            text = 'OBSERVATION:\n' + obs.content
+            text = obs_prefix + obs.content
             # replace base64 images with a placeholder
             splitted = text.split('\n')
             for i, line in enumerate(splitted):
@@ -165,11 +152,23 @@ class CodeActAgent(Agent):
             text = truncate_content(text, max_message_chars)
             return Message(role='user', content=[TextContent(text=text)])
         elif isinstance(obs, AgentDelegateObservation):
-            text = 'OBSERVATION:\n' + truncate_content(
-                str(obs.outputs), max_message_chars
+            text = obs_prefix + truncate_content(
+                obs.outputs['content'] if 'content' in obs.outputs else '',
+                max_message_chars,
             )
             return Message(role='user', content=[TextContent(text=text)])
-        return None
+        elif isinstance(obs, ErrorObservation):
+            text = obs_prefix + truncate_content(obs.content, max_message_chars)
+            text += '\n[Error occurred in processing last action]'
+            return Message(role='user', content=[TextContent(text=text)])
+        elif isinstance(obs, UserRejectObservation):
+            text = 'OBSERVATION:\n' + truncate_content(obs.content, max_message_chars)
+            text += '\n[Last action has been rejected by the user]'
+            return Message(role='user', content=[TextContent(text=text)])
+        else:
+            # If an observation message is not returned, it will cause an error
+            # when the LLM tries to return the next message
+            raise ValueError(f'Unknown observation type: {type(obs)}')
 
     def reset(self) -> None:
         """Resets the CodeAct Agent."""
@@ -196,22 +195,44 @@ class CodeActAgent(Agent):
 
         # prepare what we want to send to the LLM
         messages = self._get_messages(state)
-
-        response = self.llm.completion(
-            messages=[message.model_dump() for message in messages],
-            stop=[
+        params = {
+            'messages': self.llm.format_messages_for_llm(messages),
+            'stop': [
                 '</execute_ipython>',
                 '</execute_bash>',
                 '</execute_browse>',
             ],
-            temperature=0.0,
-        )
+        }
+
+        if self.llm.is_caching_prompt_active():
+            params['extra_headers'] = {
+                'anthropic-beta': 'prompt-caching-2024-07-31',
+            }
+
+        response = self.llm.completion(**params)
+
         return self.action_parser.parse(response)
 
     def _get_messages(self, state: State) -> list[Message]:
         messages: list[Message] = [
-            Message(role='system', content=[TextContent(text=self.system_message)]),
-            Message(role='user', content=[TextContent(text=self.in_context_example)]),
+            Message(
+                role='system',
+                content=[
+                    TextContent(
+                        text=self.prompt_manager.system_message,
+                        cache_prompt=self.llm.is_caching_prompt_active(),  # Cache system prompt
+                    )
+                ],
+            ),
+            Message(
+                role='user',
+                content=[
+                    TextContent(
+                        text=self.prompt_manager.initial_user_message,
+                        cache_prompt=self.llm.is_caching_prompt_active(),  # if the user asks the same query,
+                    )
+                ],
+            ),
         ]
 
         for event in state.history.get_events():
@@ -227,42 +248,38 @@ class CodeActAgent(Agent):
             if message:
                 # handle error if the message is the SAME role as the previous message
                 # litellm.exceptions.BadRequestError: litellm.BadRequestError: OpenAIException - Error code: 400 - {'detail': 'Only supports u/a/u/a/u...'}
-                # there should not have two consecutive messages from the same role
+                # there shouldn't be two consecutive messages from the same role
                 if messages and messages[-1].role == message.role:
                     messages[-1].content.extend(message.content)
                 else:
                     messages.append(message)
 
-        # the latest user message is important:
+        # Add caching to the last 2 user messages
+        if self.llm.is_caching_prompt_active():
+            user_turns_processed = 0
+            for message in reversed(messages):
+                if message.role == 'user' and user_turns_processed < 2:
+                    message.content[
+                        -1
+                    ].cache_prompt = True  # Last item inside the message content
+                    user_turns_processed += 1
+
+        # The latest user message is important:
         # we want to remind the agent of the environment constraints
         latest_user_message = next(
-            (
-                m
-                for m in reversed(messages)
-                if m.role == 'user'
-                and any(isinstance(c, TextContent) for c in m.content)
+            islice(
+                (
+                    m
+                    for m in reversed(messages)
+                    if m.role == 'user'
+                    and any(isinstance(c, TextContent) for c in m.content)
+                ),
+                1,
             ),
             None,
         )
-
-        # Get the last user text inside content
         if latest_user_message:
-            latest_user_message_text = next(
-                (
-                    t
-                    for t in reversed(latest_user_message.content)
-                    if isinstance(t, TextContent)
-                )
-            )
-            # add a reminder to the prompt
             reminder_text = f'\n\nENVIRONMENT REMINDER: You have {state.max_iterations - state.iteration} turns left to complete the task. When finished reply with <finish></finish>.'
-
-            if latest_user_message_text:
-                latest_user_message_text.text = (
-                    latest_user_message_text.text + reminder_text
-                )
-            else:
-                latest_user_message_text = TextContent(text=reminder_text)
-                latest_user_message.content.append(latest_user_message_text)
+            latest_user_message.content.append(TextContent(text=reminder_text))
 
         return messages

agenthub/codeact_agent/micro/github.md

@@ -0,0 +1,69 @@
+---
+name: github
+agent: CodeActAgent
+require_env_var:
+    SANDBOX_ENV_GITHUB_TOKEN: "Create a GitHub Personal Access Token (https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) and set it as SANDBOX_GITHUB_TOKEN in your environment variables."
+---
+
+# How to Interact with Github
+
+## Environment Variable Available
+
+- `GITHUB_TOKEN`: A read-only token for Github.
+
+## Using GitHub's RESTful API
+
+Use `curl` with the `GITHUB_TOKEN` to interact with GitHub's API. Here are some common operations:
+
+Here's a template for API calls:
+
+```sh
+curl -H "Authorization: token $GITHUB_TOKEN" \
+    "https://api.github.com/{endpoint}"
+```
+
+First replace `{endpoint}` with the specific API path. Common operations:
+
+1. View an issue or pull request:
+   - Issues: `/repos/{owner}/{repo}/issues/{issue_number}`
+   - Pull requests: `/repos/{owner}/{repo}/pulls/{pull_request_number}`
+
+2. List repository issues or pull requests:
+   - Issues: `/repos/{owner}/{repo}/issues`
+   - Pull requests: `/repos/{owner}/{repo}/pulls`
+
+3. Search issues or pull requests:
+   - `/search/issues?q=repo:{owner}/{repo}+is:{type}+{search_term}+state:{state}`
+   - Replace `{type}` with `issue` or `pr`
+
+4. List repository branches:
+   `/repos/{owner}/{repo}/branches`
+
+5. Get commit details:
+   `/repos/{owner}/{repo}/commits/{commit_sha}`
+
+6. Get repository details:
+   `/repos/{owner}/{repo}`
+
+7. Get user information:
+   `/user`
+
+8. Search repositories:
+   `/search/repositories?q={query}`
+
+9. Get rate limit status:
+   `/rate_limit`
+
+Replace `{owner}`, `{repo}`, `{commit_sha}`, `{issue_number}`, `{pull_request_number}`,
+`{search_term}`, `{state}`, and `{query}` with appropriate values.
+
+## Important Notes
+
+1. Always use the GitHub API for operations instead of a web browser.
+2. The `GITHUB_TOKEN` is read-only. Avoid operations that require write access.
+3. Git config (username and email) is pre-set. Do not modify.
+4. Edit and test code locally. Never push directly to remote.
+5. Verify correct branch before committing.
+6. Commit changes frequently.
+7. If the issue or task is ambiguous or lacks sufficient detail, always request clarification from the user before proceeding.
+8. You should avoid using command line tools like `sed` for file editing.

agenthub/codeact_agent/system_prompt.j2

@@ -0,0 +1,52 @@
+{% set MINIMAL_SYSTEM_PREFIX %}
+A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed answers to the user's questions.
+The assistant can use a Python environment with <execute_ipython>, e.g.:
+<execute_ipython>
+print("Hello World!")
+</execute_ipython>
+The assistant can execute bash commands wrapped with <execute_bash>, e.g. <execute_bash> ls </execute_bash>.
+If a bash command returns exit code `-1`, this means the process is not yet finished.
+The assistant must then send a second <execute_bash>. The second <execute_bash> can be empty
+(which will retrieve any additional logs), or it can contain text to be sent to STDIN of the running process,
+or it can contain the text `ctrl+c` to interrupt the process.
+
+For commands that may run indefinitely, the output should be redirected to a file and the command run
+in the background, e.g. <execute_bash> python3 app.py > server.log 2>&1 & </execute_bash>
+If a command execution result says "Command timed out. Sending SIGINT to the process",
+the assistant should retry running the command in the background.
+{% endset %}
+{% set BROWSING_PREFIX %}
+The assistant can browse the Internet with <execute_browse> and </execute_browse>.
+For example, <execute_browse> Tell me the usa's president using google search </execute_browse>.
+Or <execute_browse> Tell me what is in http://example.com </execute_browse>.
+{% endset %}
+{% set PIP_INSTALL_PREFIX %}
+The assistant can install Python packages using the %pip magic command in an IPython environment by using the following syntax: <execute_ipython> %pip install [package needed] </execute_ipython> and should always import packages and define variables before starting to use them.
+{% endset %}
+{% set SYSTEM_PREFIX = MINIMAL_SYSTEM_PREFIX + BROWSING_PREFIX + PIP_INSTALL_PREFIX %}
+{% set COMMAND_DOCS %}
+Apart from the standard Python library, the assistant can also use the following functions (already imported) in <execute_ipython> environment:
+{{ agent_skills_docs }}
+IMPORTANT:
+- `open_file` only returns the first 100 lines of the file by default! The assistant MUST use `scroll_down` repeatedly to read the full file BEFORE making edits!
+- The assistant shall adhere to THE `edit_file_by_replace`, `append_file` and `insert_content_at_line` FUNCTIONS REQUIRING PROPER INDENTATION. If the assistant would like to add the line '        print(x)', it must fully write the line out, with all leading spaces before the code!
+- Indentation is important and code that is not indented correctly will fail and require fixing before it can be run.
+- Any code issued should be less than 50 lines to avoid context being cut off!
+- After EVERY `create_file` the method `append_file` shall be used to write the FIRST content!
+- For `edit_file_by_replace` NEVER provide empty parameters!
+- For `edit_file_by_replace` the file must be read fully before any replacements!
+{% endset %}
+{% set SYSTEM_SUFFIX %}
+Responses should be concise.
+The assistant should attempt fewer things at a time instead of putting too many commands OR too much code in one "execute" block.
+Include ONLY ONE <execute_ipython>, <execute_bash>, or <execute_browse> per response, unless the assistant is finished with the task or needs more input or action from the user in order to proceed.
+If the assistant is finished with the task you MUST include <finish></finish> in your response.
+IMPORTANT: Execute code using <execute_ipython>, <execute_bash>, or <execute_browse> whenever possible.
+The assistant should utilize full file paths and the `pwd` command to prevent path-related errors.
+The assistant must avoid apologies and thanks in its responses.
+
+{% endset %}
+{# Combine all parts without newlines between them #}
+{{ SYSTEM_PREFIX -}}
+{{- COMMAND_DOCS -}}
+{{- SYSTEM_SUFFIX }}

agenthub/codeact_agent/user_prompt.j2

@@ -1,52 +1,4 @@
-from opendevin.runtime.plugins import AgentSkillsRequirement
-
-_AGENT_SKILLS_DOCS = AgentSkillsRequirement.documentation
-
-COMMAND_DOCS = (
-    '\nApart from the standard Python library, the assistant can also use the following functions (already imported) in <execute_ipython> environment:\n'
-    f'{_AGENT_SKILLS_DOCS}'
-    "Please note that THE `edit_file_by_replace`, `append_file` and `insert_content_at_line` FUNCTIONS REQUIRE PROPER INDENTATION. If the assistant would like to add the line '        print(x)', it must fully write that out, with all those spaces before the code! Indentation is important and code that is not indented correctly will fail and require fixing before it can be run."
-)
-
-# ======= SYSTEM MESSAGE =======
-MINIMAL_SYSTEM_PREFIX = """A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.
-The assistant can use an interactive Python (Jupyter Notebook) environment, executing code with <execute_ipython>.
-<execute_ipython>
-print("Hello World!")
-</execute_ipython>
-The assistant can execute bash commands on behalf of the user by wrapping them with <execute_bash> and </execute_bash>.
-
-For example, you can list the files in the current directory by <execute_bash> ls </execute_bash>.
-Important, however: do not run interactive commands. You do not have access to stdin.
-Also, you need to handle commands that may run indefinitely and not return a result. For such cases, you should redirect the output to a file and run the command in the background to avoid blocking the execution.
-For example, to run a Python script that might run indefinitely without returning immediately, you can use the following format: <execute_bash> python3 app.py > server.log 2>&1 & </execute_bash>
-Also, if a command execution result saying like: Command: "npm start" timed out. Sending SIGINT to the process, you should also retry with running the command in the background.
-"""
-
-BROWSING_PREFIX = """The assistant can browse the Internet with <execute_browse> and </execute_browse>.
-For example, <execute_browse> Tell me the usa's president using google search </execute_browse>.
-Or <execute_browse> Tell me what is in http://example.com </execute_browse>.
-"""
-PIP_INSTALL_PREFIX = """The assistant can install Python packages using the %pip magic command in an IPython environment by using the following syntax: <execute_ipython> %pip install [package needed] </execute_ipython> and should always import packages and define variables before starting to use them."""
-
-SYSTEM_PREFIX = MINIMAL_SYSTEM_PREFIX + BROWSING_PREFIX + PIP_INSTALL_PREFIX
-
-GITHUB_MESSAGE = """To interact with GitHub, use the $GITHUB_TOKEN environment variable.
-For example, to push a branch `my_branch` to the GitHub repo `owner/repo`:
-<execute_bash> git push https://$GITHUB_TOKEN@github.com/owner/repo.git my_branch </execute_bash>
-If $GITHUB_TOKEN is not set, ask the user to set it."""
-
-SYSTEM_SUFFIX = """Responses should be concise.
-The assistant should attempt fewer things at a time instead of putting too many commands OR too much code in one "execute" block.
-Include ONLY ONE <execute_ipython>, <execute_bash>, or <execute_browse> per response, unless the assistant is finished with the task or needs more input or action from the user in order to proceed.
-If the assistant is finished with the task you MUST include <finish></finish> in your response.
-IMPORTANT: Execute code using <execute_ipython>, <execute_bash>, or <execute_browse> whenever possible.
-When handling files, try to use full paths and pwd to avoid errors.
-"""
-
-
-# ======= EXAMPLE MESSAGE =======
-EXAMPLES = """
+{% set DEFAULT_EXAMPLE %}
 --- START OF EXAMPLE ---
 
 USER: Create a list of numbers from 1 to 10, and display them in a web page at port 5000.
@@ -68,7 +20,7 @@ OBSERVATION:
 ASSISTANT:
 Now I will write the Python code for starting a web server and save it to the file `app.py`:
 <execute_ipython>
-EDITED_CODE=\"\"\"from flask import Flask
+EDITED_CODE="""from flask import Flask
 app = Flask(__name__)
 
 @app.route('/')
@@ -77,7 +29,7 @@ def index():
     return str(numbers)
 
 if __name__ == '__main__':
-    app.run(port=5000)\"\"\"
+    app.run(port=5000)"""
 
 insert_content_at_line(
   'app.py',
@@ -143,8 +95,8 @@ Collecting click>=8.1.3
   Using cached click-8.1.7-py3-none-any.whl (97 kB)
 Collecting itsdangerous>=2.1.2
   Using cached itsdangerous-2.2.0-py3-none-any.whl (16 kB)
-Requirement already satisfied: Jinja2>=3.1.2 in /home/opendevin/.local/lib/python3.10/site-packages (from flask) (3.1.3)
-Requirement already satisfied: MarkupSafe>=2.0 in /home/opendevin/.local/lib/python3.10/site-packages (from Jinja2>=3.1.2->flask) (2.1.5)
+Requirement already satisfied: Jinja2>=3.1.2 in /home/openhands/.local/lib/python3.10/site-packages (from flask) (3.1.3)
+Requirement already satisfied: MarkupSafe>=2.0 in /home/openhands/.local/lib/python3.10/site-packages (from Jinja2>=3.1.2->flask) (2.1.5)
 Installing collected packages: Werkzeug, itsdangerous, click, blinker, flask
 Successfully installed Werkzeug-3.0.2 blinker-1.7.0 click-8.1.7 flask-3.0.3 itsdangerous-2.2.0
 
@@ -265,11 +217,15 @@ The server is running on port 5000 with PID 126. You can access the list of numb
 <finish></finish>
 
 --- END OF EXAMPLE ---
-"""
+{% endset %}
+Here is an example of how you can interact with the environment for task solving:
+{{ DEFAULT_EXAMPLE }}
+{% if micro_agent %}
+--- BEGIN OF GUIDELINE ---
+The following information may assist you in completing your task:
 
-INVALID_INPUT_MESSAGE = (
-    "I don't understand your input. \n"
-    'For bash commands, use <execute_bash> YOUR_COMMAND </execute_bash>.\n'
-    'For Python code, use <execute_ipython> YOUR_CODE </execute_ipython>.\n'
-    'For browsing, use <execute_browse> YOUR_COMMAND </execute_browse>.\n'
-)
+{{ micro_agent }}
+--- END OF GUIDELINE ---
+{% endif %}
+
+NOW, LET'S START!

agenthub/codeact_swe_agent/README.md

@@ -1,6 +1,6 @@
 # CodeAct (SWE Edit Specialized)
 
-This agent is an adaptation of the original [SWE Agent](https://swe-agent.com/) based on CodeAct using the `agentskills` library of OpenDevin.
+This agent is an adaptation of the original [SWE Agent](https://swe-agent.com/) based on CodeAct using the `agentskills` library of OpenHands.
 
 Its intended use is **solving GitHub issues**.
 

agenthub/codeact_swe_agent/__init__.py

@@ -1,5 +1,4 @@
-from opendevin.controller.agent import Agent
-
-from .codeact_swe_agent import CodeActSWEAgent
+from agenthub.codeact_swe_agent.codeact_swe_agent import CodeActSWEAgent
+from openhands.controller.agent import Agent
 
 Agent.register('CodeActSWEAgent', CodeActSWEAgent)

agenthub/codeact_swe_agent/action_parser.py

@@ -1,7 +1,7 @@
 import re
 
-from opendevin.controller.action_parser import ActionParser
-from opendevin.events.action import (
+from openhands.controller.action_parser import ActionParser
+from openhands.events.action import (
     Action,
     AgentFinishAction,
     CmdRunAction,

agenthub/codeact_swe_agent/codeact_swe_agent.py

@@ -5,29 +5,30 @@ from agenthub.codeact_swe_agent.prompt import (
     SYSTEM_SUFFIX,
 )
 from agenthub.codeact_swe_agent.response_parser import CodeActSWEResponseParser
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.core.message import ImageContent, Message, TextContent
-from opendevin.events.action import (
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.core.message import ImageContent, Message, TextContent
+from openhands.events.action import (
     Action,
     AgentFinishAction,
     CmdRunAction,
     IPythonRunCellAction,
     MessageAction,
 )
-from opendevin.events.observation import (
+from openhands.events.observation import (
     CmdOutputObservation,
     IPythonRunCellObservation,
 )
-from opendevin.events.observation.observation import Observation
-from opendevin.events.serialization.event import truncate_content
-from opendevin.llm.llm import LLM
-from opendevin.runtime.plugins import (
+from openhands.events.observation.error import ErrorObservation
+from openhands.events.observation.observation import Observation
+from openhands.events.serialization.event import truncate_content
+from openhands.llm.llm import LLM
+from openhands.runtime.plugins import (
     AgentSkillsRequirement,
     JupyterRequirement,
     PluginRequirement,
 )
-from opendevin.runtime.tools import RuntimeTool
 
 
 def get_system_message() -> str:
@@ -41,7 +42,7 @@ def get_in_context_example() -> str:
 class CodeActSWEAgent(Agent):
     VERSION = '1.6'
     """
-    This agent is an adaptation of the original [SWE Agent](https://swe-agent.com/) based on CodeAct 1.5 using the `agentskills` library of OpenDevin.
+    This agent is an adaptation of the original [SWE Agent](https://swe-agent.com/) based on CodeAct 1.5 using the `agentskills` library of OpenHands.
 
     It is intended use is **solving Github issues**.
 
@@ -55,7 +56,6 @@ class CodeActSWEAgent(Agent):
         AgentSkillsRequirement(),
         JupyterRequirement(),
     ]
-    runtime_tools: list[RuntimeTool] = []
 
     system_message: str = get_system_message()
     in_context_example: str = f"Here is an example of how you can interact with the environment for task solving:\n{get_in_context_example()}\n\nNOW, LET'S START!"
@@ -65,13 +65,14 @@ class CodeActSWEAgent(Agent):
     def __init__(
         self,
         llm: LLM,
+        config: AgentConfig,
     ) -> None:
-        """Initializes a new instance of the CodeActAgent class.
+        """Initializes a new instance of the CodeActSWEAgent class.
 
         Parameters:
         - llm (LLM): The llm to be used by this agent
         """
-        super().__init__(llm)
+        super().__init__(llm, config)
         self.reset()
 
     def action_to_str(self, action: Action) -> str:
@@ -93,7 +94,11 @@ class CodeActSWEAgent(Agent):
         ):
             content = [TextContent(text=self.action_to_str(action))]
 
-            if isinstance(action, MessageAction) and action.images_urls:
+            if (
+                self.llm.vision_is_active()
+                and isinstance(action, MessageAction)
+                and action.images_urls
+            ):
                 content.append(ImageContent(image_urls=action.images_urls))
 
             return Message(
@@ -122,7 +127,14 @@ class CodeActSWEAgent(Agent):
             text = '\n'.join(splitted)
             text = truncate_content(text, max_message_chars)
             return Message(role='user', content=[TextContent(text=text)])
-        return None
+        elif isinstance(obs, ErrorObservation):
+            text = 'OBSERVATION:\n' + truncate_content(obs.content, max_message_chars)
+            text += '\n[Error occurred in processing last action]'
+            return Message(role='user', content=[TextContent(text=text)])
+        else:
+            # If an observation message is not returned, it will cause an error
+            # when the LLM tries to return the next message
+            raise ValueError(f'Unknown observation type: {type(obs)}')
 
     def reset(self) -> None:
         """Resets the CodeAct Agent."""
@@ -148,9 +160,8 @@ class CodeActSWEAgent(Agent):
 
         # prepare what we want to send to the LLM
         messages: list[Message] = self._get_messages(state)
-
         response = self.llm.completion(
-            messages=[message.model_dump() for message in messages],
+            messages=self.llm.format_messages_for_llm(messages),
             stop=[
                 '</execute_ipython>',
                 '</execute_bash>',

agenthub/codeact_swe_agent/prompt.py

@@ -1,4 +1,4 @@
-from opendevin.runtime.plugins import AgentSkillsRequirement
+from openhands.runtime.plugins import AgentSkillsRequirement
 
 _AGENT_SKILLS_DOCS = AgentSkillsRequirement.documentation
 

agenthub/codeact_swe_agent/response_parser.py

@@ -4,8 +4,8 @@ from agenthub.codeact_swe_agent.action_parser import (
     CodeActSWEActionParserIPythonRunCell,
     CodeActSWEActionParserMessage,
 )
-from opendevin.controller.action_parser import ResponseParser
-from opendevin.events.action import Action
+from openhands.controller.action_parser import ResponseParser
+from openhands.events.action import Action
 
 
 class CodeActSWEResponseParser(ResponseParser):

agenthub/delegator_agent/__init__.py

@@ -1,5 +1,4 @@
-from opendevin.controller.agent import Agent
-
-from .agent import DelegatorAgent
+from agenthub.delegator_agent.agent import DelegatorAgent
+from openhands.controller.agent import Agent
 
 Agent.register('DelegatorAgent', DelegatorAgent)

agenthub/delegator_agent/agent.py

@@ -1,8 +1,9 @@
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.events.action import Action, AgentDelegateAction, AgentFinishAction
-from opendevin.events.observation import AgentDelegateObservation
-from opendevin.llm.llm import LLM
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.events.action import Action, AgentDelegateAction, AgentFinishAction
+from openhands.events.observation import AgentDelegateObservation
+from openhands.llm.llm import LLM
 
 
 class DelegatorAgent(Agent):
@@ -13,13 +14,13 @@ class DelegatorAgent(Agent):
 
     current_delegate: str = ''
 
-    def __init__(self, llm: LLM):
+    def __init__(self, llm: LLM, config: AgentConfig):
         """Initialize the Delegator Agent with an LLM
 
         Parameters:
         - llm (LLM): The llm to be used by this agent
         """
-        super().__init__(llm)
+        super().__init__(llm, config)
 
     def step(self, state: State) -> Action:
         """Checks to see if current step is completed, returns AgentFinishAction if True.

agenthub/dummy_agent/__init__.py

@@ -1,5 +1,4 @@
-from opendevin.controller.agent import Agent
-
-from .agent import DummyAgent
+from agenthub.dummy_agent.agent import DummyAgent
+from openhands.controller.agent import Agent
 
 Agent.register('DummyAgent', DummyAgent)

agenthub/dummy_agent/agent.py

@@ -1,9 +1,10 @@
 from typing import TypedDict, Union
 
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.core.schema import AgentState
-from opendevin.events.action import (
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.core.schema import AgentState
+from openhands.events.action import (
     Action,
     AddTaskAction,
     AgentFinishAction,
@@ -16,7 +17,7 @@ from opendevin.events.action import (
     MessageAction,
     ModifyTaskAction,
 )
-from opendevin.events.observation import (
+from openhands.events.observation import (
     AgentStateChangedObservation,
     CmdOutputObservation,
     FileReadObservation,
@@ -24,8 +25,8 @@ from opendevin.events.observation import (
     NullObservation,
     Observation,
 )
-from opendevin.events.serialization.event import event_to_dict
-from opendevin.llm.llm import LLM
+from openhands.events.serialization.event import event_to_dict
+from openhands.llm.llm import LLM
 
 """
 FIXME: There are a few problems this surfaced
@@ -45,8 +46,8 @@ class DummyAgent(Agent):
     without making any LLM calls.
     """
 
-    def __init__(self, llm: LLM):
-        super().__init__(llm)
+    def __init__(self, llm: LLM, config: AgentConfig):
+        super().__init__(llm, config)
         self.steps: list[ActionObs] = [
             {
                 'action': AddTaskAction(

agenthub/micro/agent.py

@@ -1,17 +1,17 @@
 from jinja2 import BaseLoader, Environment
 
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.core.message import ImageContent, Message, TextContent
-from opendevin.core.utils import json
-from opendevin.events.action import Action
-from opendevin.events.serialization.action import action_from_dict
-from opendevin.events.serialization.event import event_to_memory
-from opendevin.llm.llm import LLM
-from opendevin.memory.history import ShortTermHistory
-
-from .instructions import instructions
-from .registry import all_microagents
+from agenthub.micro.instructions import instructions
+from agenthub.micro.registry import all_microagents
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.core.message import ImageContent, Message, TextContent
+from openhands.core.utils import json
+from openhands.events.action import Action
+from openhands.events.serialization.action import action_from_dict
+from openhands.events.serialization.event import event_to_memory
+from openhands.llm.llm import LLM
+from openhands.memory.history import ShortTermHistory
 
 
 def parse_response(orig_response: str) -> Action:
@@ -54,8 +54,8 @@ class MicroAgent(Agent):
 
         return json.dumps(processed_history, **kwargs)
 
-    def __init__(self, llm: LLM):
-        super().__init__(llm)
+    def __init__(self, llm: LLM, config: AgentConfig):
+        super().__init__(llm, config)
         if 'name' not in self.agent_definition:
             raise ValueError('Agent definition must contain a name')
         self.prompt_template = Environment(loader=BaseLoader).from_string(self.prompt)
@@ -73,10 +73,13 @@ class MicroAgent(Agent):
             latest_user_message=last_user_message,
         )
         content = [TextContent(text=prompt)]
-        if last_image_urls:
+        if self.llm.vision_is_active() and last_image_urls:
             content.append(ImageContent(image_urls=last_image_urls))
         message = Message(role='user', content=content)
-        resp = self.llm.completion(messages=[message.model_dump()])
+        resp = self.llm.completion(
+            messages=self.llm.format_messages_for_llm(message),
+            temperature=0.0,
+        )
         action_resp = resp['choices'][0]['message']['content']
         action = parse_response(action_resp)
         return action

agenthub/micro/commit_writer/README.md

@@ -4,7 +4,7 @@ CommitWriterAgent can help write git commit message. Example:
 
 ```bash
 WORKSPACE_MOUNT_PATH="`PWD`" \
-  poetry run python opendevin/core/main.py -t "dummy task" -c CommitWriterAgent -d ./
+  poetry run python openhands/core/main.py -t "dummy task" -c CommitWriterAgent -d ./
 ```
 
 This agent is special in the sense that it doesn't need a task. Once called,

agenthub/planner_agent/__init__.py

@@ -1,5 +1,4 @@
-from opendevin.controller.agent import Agent
-
-from .agent import PlannerAgent
+from agenthub.planner_agent.agent import PlannerAgent
+from openhands.controller.agent import Agent
 
 Agent.register('PlannerAgent', PlannerAgent)

agenthub/planner_agent/agent.py

@@ -1,12 +1,11 @@
+from agenthub.planner_agent.prompt import get_prompt_and_images
 from agenthub.planner_agent.response_parser import PlannerResponseParser
-from opendevin.controller.agent import Agent
-from opendevin.controller.state.state import State
-from opendevin.core.message import ImageContent, Message, TextContent
-from opendevin.events.action import Action, AgentFinishAction
-from opendevin.llm.llm import LLM
-from opendevin.runtime.tools import RuntimeTool
-
-from .prompt import get_prompt_and_images
+from openhands.controller.agent import Agent
+from openhands.controller.state.state import State
+from openhands.core.config import AgentConfig
+from openhands.core.message import ImageContent, Message, TextContent
+from openhands.events.action import Action, AgentFinishAction
+from openhands.llm.llm import LLM
 
 
 class PlannerAgent(Agent):
@@ -15,16 +14,15 @@ class PlannerAgent(Agent):
     The planner agent utilizes a special prompting strategy to create long term plans for solving problems.
     The agent is given its previous action-observation pairs, current task, and hint based on last action taken at every step.
     """
-    runtime_tools: list[RuntimeTool] = [RuntimeTool.BROWSER]
     response_parser = PlannerResponseParser()
 
-    def __init__(self, llm: LLM):
+    def __init__(self, llm: LLM, config: AgentConfig):
         """Initialize the Planner Agent with an LLM
 
         Parameters:
         - llm (LLM): The llm to be used by this agent
         """
-        super().__init__(llm)
+        super().__init__(llm, config)
 
     def step(self, state: State) -> Action:
         """Checks to see if current step is completed, returns AgentFinishAction if True.
@@ -48,8 +46,8 @@ class PlannerAgent(Agent):
             state, self.llm.config.max_message_chars
         )
         content = [TextContent(text=prompt)]
-        if image_urls:
+        if self.llm.vision_is_active() and image_urls:
             content.append(ImageContent(image_urls=image_urls))
         message = Message(role='user', content=content)
-        resp = self.llm.completion(messages=[message.model_dump()])
+        resp = self.llm.completion(messages=self.llm.format_messages_for_llm(message))
         return self.response_parser.parse(resp)

agenthub/planner_agent/prompt.py

@@ -1,13 +1,13 @@
-from opendevin.controller.state.state import State
-from opendevin.core.logger import opendevin_logger as logger
-from opendevin.core.schema import ActionType
-from opendevin.core.utils import json
-from opendevin.events.action import (
+from openhands.controller.state.state import State
+from openhands.core.logger import openhands_logger as logger
+from openhands.core.schema import ActionType
+from openhands.core.utils import json
+from openhands.events.action import (
     Action,
     NullAction,
 )
-from opendevin.events.serialization.action import action_from_dict
-from opendevin.events.serialization.event import event_to_memory
+from openhands.events.serialization.action import action_from_dict
+from openhands.events.serialization.event import event_to_memory
 
 HISTORY_SIZE = 20
 

agenthub/planner_agent/response_parser.py

@@ -1,9 +1,9 @@
-from opendevin.controller.action_parser import ResponseParser
-from opendevin.core.utils import json
-from opendevin.events.action import (
+from openhands.controller.action_parser import ResponseParser
+from openhands.core.utils import json
+from openhands.events.action import (
     Action,
 )
-from opendevin.events.serialization.action import action_from_dict
+from openhands.events.serialization.action import action_from_dict
 
 
 class PlannerResponseParser(ResponseParser):

compose.yml

@@ -0,0 +1,22 @@
+#
+services:
+  openhands:
+    build:
+      context: ./
+      dockerfile: ./containers/app/Dockerfile
+    image: openhands:latest
+    container_name: openhands-app-${DATE:-}
+    environment:
+      - SANDBOX_RUNTIME_CONTAINER_IMAGE=${SANDBOX_RUNTIME_CONTAINER_IMAGE:-ghcr.io/all-hands-ai/runtime:0.9-nikolaik}
+      - SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234}
+      - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
+    ports:
+      - "3000:3000"
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${WORKSPACE_BASE:-$PWD/workspace}:/opt/workspace_base
+    pull_policy: build
+    stdin_open: true
+    tty: true

config.template.toml

@@ -1,4 +1,4 @@
-###################### OpenDevin Configuration Example ######################
+###################### OpenHands Configuration Example ######################
 #
 # All settings have default values, so you only need to uncomment and
 # modify what you want to change
@@ -55,8 +55,8 @@ workspace_base = "./workspace"
 # Path to rewrite the workspace mount path to
 #workspace_mount_rewrite = ""
 
-# Run as devin
-#run_as_devin = true
+# Run as openhands
+#run_as_openhands = true
 
 # Runtime environment
 #runtime = "eventstream"
@@ -64,6 +64,15 @@ workspace_base = "./workspace"
 # Name of the default agent
 #default_agent = "CodeActAgent"
 
+# JWT secret for authentication
+#jwt_secret = ""
+
+# Restrict file types for file uploads
+#file_uploads_restrict_file_types = false
+
+# List of allowed file extensions for uploads
+#file_uploads_allowed_extensions = [".*"]
+
 #################################### LLM #####################################
 # Configuration for LLM models (group name starts with 'llm')
 # use 'llm' for the default LLM config
@@ -117,14 +126,31 @@ embedding_model = ""
 # Model to use
 model = "gpt-4o"
 
-# Number of retries to attempt
-#num_retries = 5
+# Number of retries to attempt when an operation fails with the LLM.
+# Increase this value to allow more attempts before giving up
+#num_retries = 8
 
-# Retry maximum wait time
-#retry_max_wait = 60
+# Maximum wait time (in seconds) between retry attempts
+# This caps the exponential backoff to prevent excessively long
+#retry_max_wait = 120
 
-# Retry minimum wait time
-#retry_min_wait = 3
+# Minimum wait time (in seconds) between retry attempts
+# This sets the initial delay before the first retry
+#retry_min_wait = 15
+
+# Multiplier for exponential backoff calculation
+# The wait time increases by this factor after each failed attempt
+# A value of 2.0 means each retry waits twice as long as the previous one
+#retry_multiplier = 2.0
+
+# Drop any unmapped (unsupported) params without causing an exception
+#drop_params = false
+
+# Using the prompt caching feature provided by the LLM
+#caching_prompt = false
+
+# Base URL for the OLLAMA API
+#ollama_base_url = ""
 
 # Temperature for the API
 #temperature = 0.0
@@ -133,14 +159,17 @@ model = "gpt-4o"
 #timeout = 0
 
 # Top p for the API
-#top_p = 0.5
+#top_p = 1.0
 
-[llm.gpt3]
+# If model is vision capable, this option allows to disable image processing (useful for cost reduction).
+#disable_vision = true
+
+[llm.gpt4o-mini]
 # API key to use
 api_key = "your-api-key"
 
 # Model to use
-model = "gpt-3.5"
+model = "gpt-4o-mini"
 
 #################################### Agent ###################################
 # Configuration for agents (group name starts with 'agent')
@@ -149,6 +178,9 @@ model = "gpt-3.5"
 # agent.CodeActAgent
 ##############################################################################
 [agent]
+# Name of the micro agent to use for this agent
+#micro_agent_name = ""
+
 # Memory enabled
 #memory_enabled = false
 
@@ -174,7 +206,7 @@ llm_config = 'gpt3'
 #user_id = 1000
 
 # Container image to use for the sandbox
-#container_image = "nikolaik/python-nodejs:python3.11-nodejs22"
+#base_container_image = "nikolaik/python-nodejs:python3.11-nodejs22"
 
 # Use host network
 #use_host_network = false
@@ -182,6 +214,29 @@ llm_config = 'gpt3'
 # Enable auto linting after editing
 #enable_auto_lint = false
 
+# Whether to initialize plugins
+#initialize_plugins = true
+
+# Extra dependencies to install in the runtime image
+#runtime_extra_deps = ""
+
+# Environment variables to set at the launch of the runtime
+#runtime_startup_env_vars = {}
+
+# BrowserGym environment to use for evaluation
+#browsergym_eval_env = ""
+
+#################################### Security ###################################
+# Configuration for security features
+##############################################################################
+[security]
+
+# Enable confirmation mode
+#confirmation_mode = true
+
+# The security analyzer to use
+#security_analyzer = ""
+
 #################################### Eval ####################################
 # Configuration for the evaluation, please refer to the specific evaluation
 # plugin for the available options

containers/README.md

@@ -7,6 +7,6 @@ by the `ghcr.yml` workflow.
 ## Building Manually
 
 ```bash
-docker build -f containers/app/Dockerfile -t opendevin .
+docker build -f containers/app/Dockerfile -t openhands .
 docker build -f containers/sandbox/Dockerfile -t sandbox .
 ```

containers/app/Dockerfile

@@ -1,4 +1,4 @@
-ARG OPEN_DEVIN_BUILD_VERSION=dev
+ARG OPENHANDS_BUILD_VERSION=dev
 FROM node:21.7.2-bookworm-slim AS frontend-builder
 
 WORKDIR /app
@@ -32,15 +32,15 @@ FROM python:3.12.3-slim AS runtime
 
 WORKDIR /app
 
-ARG OPEN_DEVIN_BUILD_VERSION #re-declare for this section
+ARG OPENHANDS_BUILD_VERSION #re-declare for this section
 
-ENV RUN_AS_DEVIN=true
+ENV RUN_AS_OPENHANDS=true
 # A random number--we need this to be different from the user's UID on the host machine
-ENV OPENDEVIN_USER_ID=42420
+ENV OPENHANDS_USER_ID=42420
 ENV SANDBOX_API_HOSTNAME=host.docker.internal
 ENV USE_HOST_NETWORK=false
 ENV WORKSPACE_BASE=/opt/workspace_base
-ENV OPEN_DEVIN_BUILD_VERSION=$OPEN_DEVIN_BUILD_VERSION
+ENV OPENHANDS_BUILD_VERSION=$OPENHANDS_BUILD_VERSION
 RUN mkdir -p $WORKSPACE_BASE
 
 RUN apt-get update -y \
@@ -52,38 +52,41 @@ RUN sed -i 's/^UID_MIN.*/UID_MIN 499/' /etc/login.defs
 RUN sed -i 's/^UID_MAX.*/UID_MAX 1000000/' /etc/login.defs
 
 RUN groupadd app
-RUN useradd -l -m -u $OPENDEVIN_USER_ID -s /bin/bash opendevin && \
-    usermod -aG app opendevin && \
-    usermod -aG sudo opendevin && \
+RUN useradd -l -m -u $OPENHANDS_USER_ID -s /bin/bash openhands && \
+    usermod -aG app openhands && \
+    usermod -aG sudo openhands && \
     echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
-RUN chown -R opendevin:app /app && chmod -R 770 /app
-RUN sudo chown -R opendevin:app $WORKSPACE_BASE && sudo chmod -R 770 $WORKSPACE_BASE
-USER opendevin
+RUN chown -R openhands:app /app && chmod -R 770 /app
+RUN sudo chown -R openhands:app $WORKSPACE_BASE && sudo chmod -R 770 $WORKSPACE_BASE
+USER openhands
 
 ENV VIRTUAL_ENV=/app/.venv \
     PATH="/app/.venv/bin:$PATH" \
     PYTHONPATH='/app'
 
-COPY --chown=opendevin:app --chmod=770 --from=backend-builder ${VIRTUAL_ENV} ${VIRTUAL_ENV}
+COPY --chown=openhands:app --chmod=770 --from=backend-builder ${VIRTUAL_ENV} ${VIRTUAL_ENV}
 RUN playwright install --with-deps chromium
 
-COPY --chown=opendevin:app --chmod=770 ./opendevin ./opendevin
-COPY --chown=opendevin:app --chmod=777 ./opendevin/runtime/plugins ./opendevin/runtime/plugins
-COPY --chown=opendevin:app --chmod=770 ./agenthub ./agenthub
-COPY --chown=opendevin:app --chmod=770 ./pyproject.toml ./pyproject.toml
-COPY --chown=opendevin:app --chmod=770 ./poetry.lock ./poetry.lock
-COPY --chown=opendevin:app --chmod=770 ./README.md ./README.md
+COPY --chown=openhands:app --chmod=770 ./openhands ./openhands
+COPY --chown=openhands:app --chmod=777 ./openhands/runtime/plugins ./openhands/runtime/plugins
+COPY --chown=openhands:app --chmod=770 ./agenthub ./agenthub
+COPY --chown=openhands:app --chmod=770 ./pyproject.toml ./pyproject.toml
+COPY --chown=openhands:app --chmod=770 ./poetry.lock ./poetry.lock
+COPY --chown=openhands:app --chmod=770 ./README.md ./README.md
+COPY --chown=openhands:app --chmod=770 ./MANIFEST.in ./MANIFEST.in
 
-RUN python opendevin/core/download.py # No-op to download assets
-RUN chown -R opendevin:app /app/logs && chmod -R 770 /app/logs # This gets created by the download.py script
+# This is run as "openhands" user, and will create __pycache__ with openhands:openhands ownership
+RUN python openhands/core/download.py # No-op to download assets
+# Add this line to set group ownership of all files/directories not already in "app" group
+# openhands:openhands -> openhands:app
+RUN find /app \! -group app -exec chgrp app {} +
 
-
-COPY --chown=opendevin:app --chmod=770 --from=frontend-builder /app/dist ./frontend/dist
-COPY --chown=opendevin:app --chmod=770 ./containers/app/entrypoint.sh /app/entrypoint.sh
+COPY --chown=openhands:app --chmod=770 --from=frontend-builder /app/dist ./frontend/dist
+COPY --chown=openhands:app --chmod=770 ./containers/app/entrypoint.sh /app/entrypoint.sh
 
 USER root
 
 WORKDIR /app
 
 ENTRYPOINT ["/app/entrypoint.sh"]
-CMD ["uvicorn", "opendevin.server.listen:app", "--host", "0.0.0.0", "--port", "3000"]
+CMD ["uvicorn", "openhands.server.listen:app", "--host", "0.0.0.0", "--port", "3000"]

containers/app/config.sh

@@ -1,4 +1,4 @@
 DOCKER_REGISTRY=ghcr.io
-DOCKER_ORG=opendevin
-DOCKER_IMAGE=opendevin
+DOCKER_ORG=all-hands-ai
+DOCKER_IMAGE=openhands
 DOCKER_BASE_DIR="."

containers/app/entrypoint.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -eo pipefail
 
-echo "Starting OpenDevin..."
+echo "Starting OpenHands..."
 if [[ $NO_SETUP == "true" ]]; then
   echo "Skipping setup, running as $(whoami)"
   "$@"
@@ -9,7 +9,7 @@ if [[ $NO_SETUP == "true" ]]; then
 fi
 
 if [ "$(id -u)" -ne 0 ]; then
-  echo "The OpenDevin entrypoint.sh must run as root"
+  echo "The OpenHands entrypoint.sh must run as root"
   exit 1
 fi
 
@@ -19,11 +19,11 @@ if [ -z "$SANDBOX_USER_ID" ]; then
 fi
 
 if [[ "$SANDBOX_USER_ID" -eq 0 ]]; then
-  echo "Running OpenDevin as root"
-  export RUN_AS_DEVIN=false
+  echo "Running OpenHands as root"
+  export RUN_AS_OPENHANDS=false
   mkdir -p /root/.cache/ms-playwright/
-  if [ -d "/home/opendevin/.cache/ms-playwright/" ]; then
-    mv /home/opendevin/.cache/ms-playwright/ /root/.cache/
+  if [ -d "/home/openhands/.cache/ms-playwright/" ]; then
+    mv /home/openhands/.cache/ms-playwright/ /root/.cache/
   fi
   "$@"
 else
@@ -32,9 +32,9 @@ else
     echo "User enduser already exists. Skipping creation."
   else
     if ! useradd -l -m -u $SANDBOX_USER_ID -s /bin/bash enduser; then
-      echo "Failed to create user enduser with id $SANDBOX_USER_ID. Moving opendevin user."
+      echo "Failed to create user enduser with id $SANDBOX_USER_ID. Moving openhands user."
       incremented_id=$(($SANDBOX_USER_ID + 1))
-      usermod -u $incremented_id opendevin
+      usermod -u $incremented_id openhands
       if ! useradd -l -m -u $SANDBOX_USER_ID -s /bin/bash enduser; then
         echo "Failed to create user enduser with id $SANDBOX_USER_ID for a second time. Exiting."
         exit 1
@@ -42,7 +42,7 @@ else
     fi
   fi
   usermod -aG app enduser
-  # get the user group of /var/run/docker.sock and set opendevin to that group
+  # get the user group of /var/run/docker.sock and set openhands to that group
   DOCKER_SOCKET_GID=$(stat -c '%g' /var/run/docker.sock)
   echo "Docker socket group id: $DOCKER_SOCKET_GID"
   if getent group $DOCKER_SOCKET_GID; then
@@ -54,11 +54,11 @@ else
 
   mkdir -p /home/enduser/.cache/huggingface/hub/
   mkdir -p /home/enduser/.cache/ms-playwright/
-  if [ -d "/home/opendevin/.cache/ms-playwright/" ]; then
-    mv /home/opendevin/.cache/ms-playwright/ /home/enduser/.cache/
+  if [ -d "/home/openhands/.cache/ms-playwright/" ]; then
+    mv /home/openhands/.cache/ms-playwright/ /home/enduser/.cache/
   fi
 
   usermod -aG $DOCKER_SOCKET_GID enduser
   echo "Running as enduser"
-  su enduser /bin/bash -c "$*"
+  su enduser /bin/bash -c "${*@Q}" # This magically runs any arguments passed to the script as a command
 fi

containers/build.sh

@@ -3,12 +3,25 @@ set -eo pipefail
 
 image_name=$1
 org_name=$2
-platform=$3
+push=0
+if [[ $3 == "--push" ]]; then
+  push=1
+fi
+tag_suffix=$4
 
-echo "Building: $image_name for platform: $platform"
+echo "Building: $image_name"
 tags=()
 
-OPEN_DEVIN_BUILD_VERSION="dev"
+OPENHANDS_BUILD_VERSION="dev"
+
+cache_tag_base="buildcache"
+cache_tag="$cache_tag_base"
+
+if [[ -n $GITHUB_SHA ]]; then
+  git_hash=$(git rev-parse --short "$GITHUB_SHA")
+  tags+=("$git_hash")
+  tags+=("$GITHUB_SHA")
+fi
 
 if [[ -n $GITHUB_REF_NAME ]]; then
   # check if ref name is a version number
@@ -18,22 +31,31 @@ if [[ -n $GITHUB_REF_NAME ]]; then
     tags+=("$major_version" "$minor_version")
     tags+=("latest")
   fi
-  sanitized=$(echo "$GITHUB_REF_NAME" | sed 's/[^a-zA-Z0-9.-]\+/-/g')
-  OPEN_DEVIN_BUILD_VERSION=$sanitized
-  tag=$(echo "$sanitized" | tr '[:upper:]' '[:lower:]') # lower case is required in tagging
-  tags+=("$tag")
+  sanitized_ref_name=$(echo "$GITHUB_REF_NAME" | sed 's/[^a-zA-Z0-9.-]\+/-/g')
+  OPENHANDS_BUILD_VERSION=$sanitized_ref_name
+  sanitized_ref_name=$(echo "$sanitized_ref_name" | tr '[:upper:]' '[:lower:]') # lower case is required in tagging
+  tags+=("$sanitized_ref_name")
+  cache_tag+="-${sanitized_ref_name}"
 fi
+
+if [[ -n $tag_suffix ]]; then
+  cache_tag+="-${tag_suffix}"
+  for i in "${!tags[@]}"; do
+    tags[$i]="${tags[$i]}-$tag_suffix"
+  done
+fi
+
 echo "Tags: ${tags[@]}"
 
-if [[ "$image_name" == "opendevin" ]]; then
+if [[ "$image_name" == "openhands" ]]; then
   dir="./containers/app"
-elif [[ "$image_name" == "od_runtime" ]]; then
+elif [[ "$image_name" == "runtime" ]]; then
   dir="./containers/runtime"
 else
   dir="./containers/$image_name"
 fi
 
-if [[ (! -f "$dir/Dockerfile") && "$image_name" != "od_runtime" ]]; then
+if [[ (! -f "$dir/Dockerfile") && "$image_name" != "runtime" ]]; then
   # Allow runtime to be built without a Dockerfile
   echo "No Dockerfile found"
   exit 1
@@ -49,15 +71,14 @@ if [[ -n "$org_name" ]]; then
   DOCKER_ORG="$org_name"
 fi
 
-# If $DOCKER_IMAGE_TAG is set, add it to the tags
-if [[ -n "$DOCKER_IMAGE_TAG" ]]; then
-  tags+=("$DOCKER_IMAGE_TAG")
-fi
 # If $DOCKER_IMAGE_HASH_TAG is set, add it to the tags
 if [[ -n "$DOCKER_IMAGE_HASH_TAG" ]]; then
   tags+=("$DOCKER_IMAGE_HASH_TAG")
 fi
-
+# If $DOCKER_IMAGE_TAG is set, add it to the tags
+if [[ -n "$DOCKER_IMAGE_TAG" ]]; then
+  tags+=("$DOCKER_IMAGE_TAG")
+fi
 
 DOCKER_REPOSITORY="$DOCKER_REGISTRY/$DOCKER_ORG/$DOCKER_IMAGE"
 DOCKER_REPOSITORY=${DOCKER_REPOSITORY,,} # lowercase
@@ -69,15 +90,19 @@ for tag in "${tags[@]}"; do
   args+=" -t $DOCKER_REPOSITORY:$tag"
 done
 
-output_image="/tmp/${image_name}_image_${platform}.tar"
+if [[ $push -eq 1 ]]; then
+  args+=" --push"
+  args+=" --cache-to=type=registry,ref=$DOCKER_REPOSITORY:$cache_tag,mode=max"
+fi
+
+echo "Args: $args"
 
 docker buildx build \
   $args \
-  --build-arg OPEN_DEVIN_BUILD_VERSION="$OPEN_DEVIN_BUILD_VERSION" \
-  --platform linux/$platform \
+  --build-arg OPENHANDS_BUILD_VERSION="$OPENHANDS_BUILD_VERSION" \
+  --cache-from=type=registry,ref=$DOCKER_REPOSITORY:$cache_tag \
+  --cache-from=type=registry,ref=$DOCKER_REPOSITORY:$cache_tag_base-main \
+  --platform linux/amd64,linux/arm64 \
   --provenance=false \
   -f "$dir/Dockerfile" \
-  --output type=docker,dest="$output_image" \
   "$DOCKER_BASE_DIR"
-
-echo "${tags[*]}" > tags.txt

containers/dev/Dockerfile

@@ -0,0 +1,124 @@
+# syntax=docker/dockerfile:1
+
+###
+FROM ubuntu:22.04 AS dind
+
+# https://docs.docker.com/engine/install/ubuntu/
+RUN apt-get update && apt-get install -y \
+	ca-certificates \
+	curl \
+	&& install -m 0755 -d /etc/apt/keyrings \
+	&& curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc \
+	&& chmod a+r /etc/apt/keyrings/docker.asc \
+	&& echo \
+		"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
+		$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
+
+RUN apt-get update && apt-get install -y \
+	docker-ce \
+	docker-ce-cli \
+	containerd.io \
+	docker-buildx-plugin \
+	docker-compose-plugin \
+	&& rm -rf /var/lib/apt/lists/* \
+	&& apt-get clean \
+	&& apt-get autoremove -y
+
+###
+FROM dind AS openhands
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+#
+RUN apt-get update && apt-get install -y \
+	bash \
+    build-essential \
+    curl \
+	git \
+	git-lfs \
+	software-properties-common \
+	make \
+    netcat \
+    sudo \
+	wget \
+	&& rm -rf /var/lib/apt/lists/* \
+	&& apt-get clean \
+	&& apt-get autoremove -y
+
+# https://github.com/cli/cli/blob/trunk/docs/install_linux.md
+RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg \
+	&& chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \
+	&& echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
+	&& apt-get update && apt-get -y install \
+    gh \
+  && rm -rf /var/lib/apt/lists/* \
+  && apt-get clean \
+  && apt-get autoremove -y
+
+# Python 3.11
+RUN add-apt-repository ppa:deadsnakes/ppa \
+    && apt-get update \
+    && apt-get install -y python3.11 python3.11-venv python3.11-dev python3-pip \
+    && ln -s /usr/bin/python3.11 /usr/bin/python
+
+# NodeJS >= 18.17.1
+RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \
+    && apt-get install -y nodejs
+
+# Poetry >= 1.8
+RUN curl -fsSL https://install.python-poetry.org | python3.11 - \
+    && ln -s ~/.local/bin/poetry /usr/local/bin/poetry
+
+#
+RUN <<EOF
+#!/bin/bash
+printf "#!/bin/bash
+set +x
+uname -a
+docker --version
+gh --version | head -n 1
+git --version
+#
+python --version
+echo node `node --version`
+echo npm `npm --version`
+poetry --version
+netcat -h 2>&1 | head -n 1
+" > /version.sh
+chmod a+x /version.sh
+EOF
+
+###
+FROM openhands AS dev
+
+RUN apt-get update && apt-get install -y \
+	dnsutils \
+	file \
+	iproute2 \
+	jq \
+	lsof \
+	ripgrep \
+	silversearcher-ag \
+	vim \
+	&& rm -rf /var/lib/apt/lists/* \
+	&& apt-get clean \
+	&& apt-get autoremove -y
+
+WORKDIR /app
+
+# cache build dependencies
+RUN \
+  --mount=type=bind,source=./,target=/app/ \
+  <<EOF
+#!/bin/bash
+make -s clean
+make -s check-dependencies
+make -s install-python-dependencies
+
+# NOTE
+# node_modules are .dockerignore-d therefore not mountable
+# make -s install-frontend-dependencies
+EOF
+
+#
+CMD ["bash"]

containers/dev/README.md

@@ -0,0 +1,54 @@
+# Develop in Docker
+
+Install [Docker](https://docs.docker.com/engine/install/) on your host machine and run:
+
+```bash
+make docker-dev
+# same as:
+cd ./containers/dev
+./dev.sh
+```
+
+It could take some time if you are running for the first time as Docker will pull all the  tools required for building OpenHands. The next time you run again, it should be instant.
+
+## Build and run
+
+If everything goes well, you should be inside a container after Docker finishes building the `openhands:dev` image similar to the following:
+
+```bash
+Build and run in Docker ...
+root@93fc0005fcd2:/app#
+```
+
+You may now proceed with the normal [build and run](../../Development.md) workflow as if you were on the host.
+
+## Make changes
+
+The source code on the host is mounted as `/app` inside docker. You may edit the files as usual either inside the Docker container or on your host with your favorite IDE/editors.
+
+The following are also mapped as readonly from your host:
+
+```yaml
+# host credentials
+- $HOME/.git-credentials:/root/.git-credentials:ro
+- $HOME/.gitconfig:/root/.gitconfig:ro
+- $HOME/.npmrc:/root/.npmrc:ro
+```
+
+## VSCode
+
+Alternatively, if you use VSCode, you could also [attach to the running container](https://code.visualstudio.com/docs/devcontainers/attach-container).
+
+See details for [developing in docker](https://code.visualstudio.com/docs/devcontainers/containers) or simply ask `OpenHands` ;-)
+
+## Rebuild dev image
+
+You could optionally pass additional options to the build script.
+
+```bash
+make docker-dev OPTIONS="--build"
+# or
+./containers/dev/dev.sh --build
+```
+
+See [docker compose run](https://docs.docker.com/reference/cli/docker/compose/run/) for more options.

containers/dev/compose.yml

@@ -0,0 +1,38 @@
+#
+services:
+  dev:
+    privileged: true
+    build:
+      context: ${OPENHANDS_WORKSPACE:-../../}
+      dockerfile: ./containers/dev/Dockerfile
+    image: openhands:dev
+    container_name: openhands-dev
+    environment:
+      - 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.9-nikolaik}
+      - SANDBOX_USER_ID=${SANDBOX_USER_ID:-1234}
+      - WORKSPACE_MOUNT_PATH=${WORKSPACE_BASE:-$PWD/workspace}
+    ports:
+      - "3000:3000"
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - ${WORKSPACE_BASE:-$PWD/workspace}:/opt/workspace_base
+      # source code
+      - ${OPENHANDS_WORKSPACE:-../../}:/app
+      # host credentials
+      - $HOME/.git-credentials:/root/.git-credentials:ro
+      - $HOME/.gitconfig:/root/.gitconfig:ro
+      - $HOME/.npmrc:/root/.npmrc:ro
+      # cache
+      - cache-data:/root/.cache
+    pull_policy: never
+    stdin_open: true
+    tty: true
+
+##
+volumes:
+  cache-data:

containers/dev/dev.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+set -o pipefail
+
+function get_docker() {
+    echo "Docker is required to build and run OpenHands."
+    echo "https://docs.docker.com/get-started/get-docker/"
+    exit 1
+}
+
+function check_tools() {
+	command -v docker &>/dev/null || get_docker
+}
+
+function exit_if_indocker() {
+    if [ -f /.dockerenv ]; then
+        echo "Running inside a Docker container. Exiting..."
+        exit 1
+    fi
+}
+
+#
+exit_if_indocker
+
+check_tools
+
+##
+OPENHANDS_WORKSPACE=$(git rev-parse --show-toplevel)
+
+cd "$OPENHANDS_WORKSPACE/containers/dev/" || exit 1
+
+##
+export BACKEND_HOST="0.0.0.0"
+#
+export SANDBOX_USER_ID=$(id -u)
+export WORKSPACE_BASE=${WORKSPACE_BASE:-$OPENHANDS_WORKSPACE/workspace}
+
+docker compose run --rm --service-ports "$@" dev
+
+##

containers/e2b-sandbox/README.md

@@ -1,4 +1,4 @@
-# How to build custom E2B sandbox for OpenDevin
+# How to build custom E2B sandbox for OpenHands
 
 [E2B](https://e2b.dev) is an [open-source](https://github.com/e2b-dev/e2b) secure cloud environment (sandbox) made for running AI-generated code and agents. E2B offers [Python](https://pypi.org/project/e2b/) and [JS/TS](https://www.npmjs.com/package/e2b) SDK to spawn and control these sandboxes.
 
@@ -11,5 +11,5 @@
 
 1. Build the sandbox
   ```sh
-  e2b template build --dockerfile ./Dockerfile --name "open-devin"
+  e2b template build --dockerfile ./Dockerfile --name "openhands"
   ```

containers/e2b-sandbox/e2b.toml

@@ -1,14 +1,14 @@
 # This is a config for E2B sandbox template.
-# You can use 'template_id' (785n69crgahmz0lkdw9h) or 'template_name (open-devin) from this config to spawn a sandbox:
+# You can use 'template_id' (785n69crgahmz0lkdw9h) or 'template_name (openhands) from this config to spawn a sandbox:
 
 # Python SDK
 # from e2b import Sandbox
-# sandbox = Sandbox(template='open-devin')
+# sandbox = Sandbox(template='openhands')
 
 # JS SDK
 # import { Sandbox } from 'e2b'
-# const sandbox = await Sandbox.create({ template: 'open-devin' })
+# const sandbox = await Sandbox.create({ template: 'openhands' })
 
 dockerfile = "Dockerfile"
-template_name = "open-devin"
+template_name = "openhands"
 template_id = "785n69crgahmz0lkdw9h"

containers/runtime/README.md

@@ -1,11 +1,12 @@
-# Dynamic constructed Dockerfile
+# Dynamically constructed Dockerfile
 
-This folder builds runtime image (sandbox), which will use a `Dockerfile` that is dynamically generated depends on the `base_image` AND a [Python source distribution](https://docs.python.org/3.10/distutils/sourcedist.html) that's based on the current commit of `opendevin`.
+This folder builds a runtime image (sandbox), which will use a dynamically generated `Dockerfile`
+that depends on the `base_image` **AND** a [Python source distribution](https://docs.python.org/3.10/distutils/sourcedist.html) that is based on the current commit of `openhands`.
 
-The following command will generate Dockerfile for `ubuntu:22.04` and the source distribution `.tar` into `containers/runtime`.
+The following command will generate a `Dockerfile` file for `nikolaik/python-nodejs:python3.11-nodejs22` (the default base image), an updated `config.sh` and the runtime source distribution files/folders into `containers/runtime`:
 
 ```bash
-poetry run python3 opendevin/runtime/utils/runtime_build.py \
-    --base_image ubuntu:22.04 \
+poetry run python3 openhands/runtime/utils/runtime_build.py \
+    --base_image nikolaik/python-nodejs:python3.11-nodejs22 \
     --build_folder containers/runtime
 ```

containers/runtime/config.sh

@@ -1,6 +1,7 @@
 DOCKER_REGISTRY=ghcr.io
-DOCKER_ORG=opendevin
+DOCKER_ORG=all-hands-ai
 DOCKER_BASE_DIR="./containers/runtime"
-# These two variables will be appended by the runtime_build.py script
-# DOCKER_IMAGE=
+DOCKER_IMAGE=runtime
+# These variables will be appended by the runtime_build.py script
 # DOCKER_IMAGE_TAG=
+# DOCKER_IMAGE_HASH_TAG=

containers/sandbox/Dockerfile

@@ -28,17 +28,17 @@ RUN mkdir -p -m0755 /var/run/sshd
 # symlink python3 to python
 RUN ln -s /usr/bin/python3 /usr/bin/python
 
-# ==== OpenDevin Runtime Client ====
-RUN mkdir -p /opendevin && mkdir -p /opendevin/logs && chmod 777 /opendevin/logs
+# ==== OpenHands Runtime Client ====
+RUN mkdir -p /openhands && mkdir -p /openhands/logs && chmod 777 /openhands/logs
 RUN wget --progress=bar:force -O Miniforge3.sh "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
-RUN bash Miniforge3.sh -b -p /opendevin/miniforge3
-RUN chmod -R g+w /opendevin/miniforge3
-RUN bash -c ". /opendevin/miniforge3/etc/profile.d/conda.sh && conda config --set changeps1 False && conda config --append channels conda-forge"
-RUN echo "" > /opendevin/bash.bashrc
+RUN bash Miniforge3.sh -b -p /openhands/miniforge3
+RUN chmod -R g+w /openhands/miniforge3
+RUN bash -c ". /openhands/miniforge3/etc/profile.d/conda.sh && conda config --set changeps1 False && conda config --append channels conda-forge"
+RUN echo "" > /openhands/bash.bashrc
 RUN rm -f Miniforge3.sh
 
 # - agentskills dependencies
-RUN /opendevin/miniforge3/bin/pip install --upgrade pip
-RUN /opendevin/miniforge3/bin/pip install jupyterlab notebook jupyter_kernel_gateway flake8
-RUN /opendevin/miniforge3/bin/pip install python-docx PyPDF2 python-pptx pylatexenc openai
-RUN /opendevin/miniforge3/bin/pip install python-dotenv toml termcolor pydantic python-docx pyyaml docker pexpect tenacity e2b browsergym minio
+RUN /openhands/miniforge3/bin/pip install --upgrade pip
+RUN /openhands/miniforge3/bin/pip install jupyterlab notebook jupyter_kernel_gateway flake8
+RUN /openhands/miniforge3/bin/pip install python-docx PyPDF2 python-pptx pylatexenc openai
+RUN /openhands/miniforge3/bin/pip install python-dotenv toml termcolor pydantic python-docx pyyaml docker pexpect tenacity e2b browsergym minio

containers/sandbox/config.sh

@@ -1,4 +1,4 @@
 DOCKER_REGISTRY=ghcr.io
-DOCKER_ORG=opendevin
+DOCKER_ORG=all-hands-ai
 DOCKER_IMAGE=sandbox
 DOCKER_BASE_DIR="."

dev_config/python/.pre-commit-config.yaml

@@ -38,6 +38,6 @@ repos:
       - id: mypy
         additional_dependencies:
           [types-requests, types-setuptools, types-pyyaml, types-toml]
-        entry: mypy --config-file dev_config/python/mypy.ini opendevin/ agenthub/
+        entry: mypy --config-file dev_config/python/mypy.ini openhands/ agenthub/
         always_run: true
         pass_filenames: false

docs/docusaurus.config.ts

@@ -3,17 +3,17 @@ import type { Config } from "@docusaurus/types";
 import { themes as prismThemes } from "prism-react-renderer";
 
 const config: Config = {
-  title: "OpenDevin",
-  tagline: "An Open Platform for AI Software Developers as Generalist Agents",
-  favicon: "img/logo.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: "/",
 
   // GitHub pages deployment config.
-  organizationName: "OpenDevin",
-  projectName: "OpenDevin",
+  organizationName: "All-Hands-AI",
+  projectName: "OpenHands",
   trailingSlash: false,
 
   onBrokenLinks: "throw",
@@ -63,9 +63,9 @@ const config: Config = {
   themeConfig: {
     image: "img/docusaurus.png",
     navbar: {
-      title: "OpenDevin",
+      title: "OpenHands",
       logo: {
-        alt: "OpenDevin",
+        alt: "OpenHands",
         src: "img/logo.png",
       },
       items: [
@@ -73,23 +73,28 @@ const config: Config = {
           type: "docSidebar",
           sidebarId: "docsSidebar",
           position: "left",
-          label: "Docs",
+          label: "User Guides",
         },
         {
           type: "docSidebar",
           sidebarId: "apiSidebar",
           position: "left",
-          label: "Codebase",
-        },
-        {
-          href: "https://github.com/OpenDevin/OpenDevin",
-          label: "GitHub",
-          position: "right",
+          label: "Python API",
         },
         {
           type: 'localeDropdown',
           position: 'left',
         },
+        {
+          href: "https://all-hands.dev",
+          label: "Company",
+          position: "right",
+        },
+        {
+          href: "https://github.com/All-Hands-AI/OpenHands",
+          label: "GitHub",
+          position: "right",
+        },
       ],
     },
     prism: {

docs/i18n/fr/code.json

@@ -1,6 +1,6 @@
 {
   "footer.title": {
-    "message": "OpenDevin"
+    "message": "OpenHands"
   },
   "footer.docs": {
     "message": "Documents"
@@ -9,7 +9,7 @@
     "message": "Communauté"
   },
   "footer.copyright": {
-    "message": "© {year} OpenDevin"
+    "message": "© {year} OpenHands"
   },
   "faq.title": {
     "message": "Questions Fréquemment Posées",
@@ -19,20 +19,20 @@
     "message": "Questions Fréquemment Posées"
   },
   "faq.section.title.1": {
-    "message": "Qu'est-ce qu'OpenDevin ?",
+    "message": "Qu'est-ce qu'OpenHands ?",
     "description": "First Section Title"
   },
   "faq.section.highlight": {
-    "message": "OpenDevin",
+    "message": "OpenHands",
     "description": "Highlight Text"
   },
   "faq.section.description.1": {
-    "message": "est un ingénieur logiciel autonome qui peut résoudre des tâches d'ingénierie logicielle et de navigation web à tout moment. Il peut exécuter des requêtes en sciences des données, telles que \"Trouver le nombre de demandes de pull à l'repository OpenDevin dans les derniers mois\", et des tâches d'ingénierie logicielle, comme \"Veuillez ajouter des tests à ce fichier et vérifier si tous les tests passent. Si ce n'est pas le cas, réparez le fichier.\"",
-    "description": "Description for OpenDevin"
+    "message": "est un ingénieur logiciel autonome qui peut résoudre des tâches d'ingénierie logicielle et de navigation web à tout moment. Il peut exécuter des requêtes en sciences des données, telles que \"Trouver le nombre de demandes de pull à l'repository OpenHands dans les derniers mois\", et des tâches d'ingénierie logicielle, comme \"Veuillez ajouter des tests à ce fichier et vérifier si tous les tests passent. Si ce n'est pas le cas, réparez le fichier.\"",
+    "description": "Description for OpenHands"
   },
   "faq.section.description.2": {
-    "message": "De plus, OpenDevin est une plateforme et communauté pour les développeurs d'agents qui souhaitent tester et évaluer de nouveaux agents.",
-    "description": "Further Description for OpenDevin"
+    "message": "De plus, OpenHands est une plateforme et communauté pour les développeurs d'agents qui souhaitent tester et évaluer de nouveaux agents.",
+    "description": "Further Description for OpenHands"
   },
   "faq.section.title.2": {
     "message": "Support",
@@ -43,15 +43,15 @@
     "description": "Support Answer"
   },
   "faq.section.title.3": {
-    "message": "Comment résoudre un problème sur GitHub avec OpenDevin ?",
+    "message": "Comment résoudre un problème sur GitHub avec OpenHands ?",
     "description": "GitHub Issue Section Title"
   },
   "faq.section.github.steps.intro": {
-    "message": "Pour résoudre un problème sur GitHub en utilisant OpenDevin, envoyez une commande à OpenDevin demandant qu'il suit des étapes comme les suivantes :",
+    "message": "Pour résoudre un problème sur GitHub en utilisant OpenHands, envoyez une commande à OpenHands demandant qu'il suit des étapes comme les suivantes :",
     "description": "GitHub Steps Introduction"
   },
   "faq.section.github.step1": {
-    "message": "Lisez l'issue https://github.com/OpenDevin/OpenDevin/issues/1611",
+    "message": "Lisez l'issue https://github.com/All-Hands-AI/OpenHands/issues/1611",
     "description": "GitHub Step 1"
   },
   "faq.section.github.step2": {
@@ -71,11 +71,11 @@
     "description": "GitHub Step 5"
   },
   "faq.section.github.steps.preRun": {
-    "message": "Avant de lancer OpenDevin, vous pouvez faire :",
+    "message": "Avant de lancer OpenHands, vous pouvez faire :",
     "description": "GitHub Steps Pre-Run"
   },
   "faq.section.github.steps.tokenInfo": {
-    "message": "où XXX est un jeton GitHub que vous avez créé et qui a les autorisations pour pousser dans le dépôt OpenDevin. Si vous n'avez pas d'autorisations de modification du dépôt OpenDevin, vous devrez peut-être changer cela en :",
+    "message": "où XXX est un jeton GitHub que vous avez créé et qui a les autorisations pour pousser dans le dépôt OpenHands. Si vous n'avez pas d'autorisations de modification du dépôt OpenHands, vous devrez peut-être changer cela en :",
     "description": "GitHub Steps Token Info"
   },
   "faq.section.github.steps.usernameInfo": {
@@ -83,23 +83,23 @@
     "description": "GitHub Steps Username Info"
   },
   "faq.section.title.4": {
-    "message": "Comment OpenDevin est-il différent de Devin ?",
+    "message": "Comment OpenHands est-il différent de Devin ?",
     "description": "Devin Section Title"
   },
-  "faq.section.devin.linkText": {
+  "faq.section.openhands.linkText": {
     "message": "Devin",
     "description": "Devin Link Text"
   },
-  "faq.section.devin.description": {
-    "message": "est un produit commercial par Cognition Inc., qui a servi d'inspiration initiale pour OpenDevin. Les deux visent à bien faire le travail d'ingénierie logicielle, mais vous pouvez télécharger, utiliser et modifier OpenDevin, tandis que Devin peut être utilisé uniquement via le site de Cognition. De plus, OpenDevin a évolué au-delà de l'inspiration initiale, et est maintenant un écosystème communautaire pour le développement d'agents en général, et nous serions ravis de vous voir rejoindre et",
+  "faq.section.openhands.description": {
+    "message": "est un produit commercial par Cognition Inc., qui a servi d'inspiration initiale pour OpenHands. Les deux visent à bien faire le travail d'ingénierie logicielle, mais vous pouvez télécharger, utiliser et modifier OpenHands, tandis que Devin peut être utilisé uniquement via le site de Cognition. De plus, OpenHands a évolué au-delà de l'inspiration initiale, et est maintenant un écosystème communautaire pour le développement d'agents en général, et nous serions ravis de vous voir rejoindre et",
     "description": "Devin Description"
   },
-  "faq.section.devin.contribute": {
+  "faq.section.openhands.contribute": {
     "message": "contribuer",
     "description": "Contribute Link"
   },
   "faq.section.title.5": {
-    "message": "Comment OpenDevin est-il différent de ChatGPT ?",
+    "message": "Comment OpenHands est-il différent de ChatGPT ?",
     "description": "ChatGPT Section Title"
   },
   "faq.section.chatgpt.description": {
@@ -114,7 +114,7 @@
     "message": "Commencer"
   },
   "welcome.message": {
-    "message": "Bienvenue à OpenDevin, un système d'IA autonome ingénieur logiciel capable d'exécuter des tâches d'ingénierie complexes et de collaborer activement avec les utilisateurs sur les projets de développement logiciel."
+    "message": "Bienvenue à OpenHands, un système d'IA autonome ingénieur logiciel capable d'exécuter des tâches d'ingénierie complexes et de collaborer activement avec les utilisateurs sur les projets de développement logiciel."
   },
   "theme.ErrorPageContent.title": {
     "message": "Cette page a planté.",

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

@@ -19,35 +19,35 @@ La réalisation d'une réplication complète des applications de production avec
 
 ## 🤝 Comment Contribuer {#how-to-contribute}
 
-OpenDevin est un projet communautaire, et nous accueillons les contributions de tout le monde. Que vous soyez développeur, chercheur, ou simplement enthousiaste à l'idée de faire progresser le domaine de l'ingénierie logicielle avec l'IA, il existe de nombreuses façons de vous impliquer :
+OpenHands est un projet communautaire, et nous accueillons les contributions de tout le monde. Que vous soyez développeur, chercheur, ou simplement enthousiaste à l'idée de faire progresser le domaine de l'ingénierie logicielle avec l'IA, il existe de nombreuses façons de vous impliquer :
 
 - **Contributions de Code :** Aidez-nous à développer les fonctionnalités de base, l'interface frontend ou les solutions de sandboxing.
 - **Recherche et Évaluation :** Contribuez à notre compréhension des LLM en ingénierie logicielle, participez à l'évaluation des modèles ou suggérez des améliorations.
-- **Retour d'Information et Tests :** Utilisez l'ensemble d'outils OpenDevin, signalez des bogues, suggérez des fonctionnalités ou fournissez des retours sur l'ergonomie.
+- **Retour d'Information et Tests :** Utilisez l'ensemble d'outils OpenHands, signalez des bogues, suggérez des fonctionnalités ou fournissez des retours sur l'ergonomie.
 
-Pour plus de détails, veuillez consulter [ce document](https://github.com/OpenDevin/OpenDevin/blob/main/CONTRIBUTING.md).
+Pour plus de détails, veuillez consulter [ce document](https://github.com/All-Hands-AI/OpenHands/blob/main/CONTRIBUTING.md).
 
 ## 🤖 Rejoignez Notre Communauté {#join-our-community}
 
-Nous avons maintenant à la fois un espace de travail Slack pour la collaboration sur la construction d'OpenDevin et un serveur Discord pour discuter de tout ce qui est lié, par exemple, à ce projet, aux LLM, aux agents, etc.
+Nous avons maintenant à la fois un espace de travail Slack pour la collaboration sur la construction d'OpenHands et un serveur Discord pour discuter de tout ce qui est lié, par exemple, à ce projet, aux LLM, aux agents, etc.
 
-- [Espace de travail Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw)
+- [Espace de travail Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA)
 - [Serveur Discord](https://discord.gg/ESHStjSjD4)
 
 Si vous souhaitez contribuer, n'hésitez pas à rejoindre notre communauté. Simplifions l'ingénierie logicielle ensemble !
 
-🐚 **Codez moins, créez plus avec OpenDevin.**
+🐚 **Codez moins, créez plus avec OpenHands.**
 
-[![Star History Chart](https://api.star-history.com/svg?repos=OpenDevin/OpenDevin&type=Date)](https://star-history.com/#OpenDevin/OpenDevin&Date)
+[![Star History Chart](https://api.star-history.com/svg?repos=All-Hands-AI/OpenHands&type=Date)](https://star-history.com/#All-Hands-AI/OpenHands&Date)
 
 ## 🛠️ Construit Avec {#built-with}
 
-OpenDevin est construit en utilisant une combinaison de cadres et de bibliothèques puissants, offrant une base robuste pour son développement. Voici les technologies clés utilisées dans le projet :
+OpenHands est construit en utilisant une combinaison de cadres et de bibliothèques puissants, offrant une base robuste pour son développement. Voici les technologies clés utilisées dans le projet :
 
 ![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)
 
-Veuillez noter que la sélection de ces technologies est en cours, et que des technologies supplémentaires peuvent être ajoutées ou des existantes supprimées au fur et à mesure de l'évolution du projet. Nous nous efforçons d'adopter les outils les plus adaptés et efficaces pour améliorer les capacités d'OpenDevin.
+Veuillez noter que la sélection de ces technologies est en cours, et que des technologies supplémentaires peuvent être ajoutées ou des existantes supprimées au fur et à mesure de l'évolution du projet. Nous nous efforçons d'adopter les outils les plus adaptés et efficaces pour améliorer les capacités d'OpenHands.
 
 ## 📜 Licence {#license}
 
-Distribué sous la licence MIT. Voir [notre licence](https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE) pour plus d'informations.
+Distribué sous la licence MIT. Voir [notre licence](https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE) pour plus d'informations.

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

@@ -18,18 +18,18 @@ L'idée conceptuelle est illustrée ci-dessous. À chaque tour, l'agent peut :
 - Exécuter toute commande `bash` Linux valide
 - Exécuter tout code `Python` valide avec [un interpréteur Python interactif](https://ipython.org/). Cela est simulé à travers la commande `bash`, voir le système de plugin ci-dessous pour plus de détails.
 
-![image](https://github.com/OpenDevin/OpenDevin/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
+![image](https://github.com/All-Hands-AI/OpenHands/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
 
 ### Système de Plugin
 
-Pour rendre l'agent CodeAct plus puissant avec seulement l'accès à l'espace d'action `bash`, l'agent CodeAct exploite le système de plugins d'OpenDevin:
+Pour rendre l'agent CodeAct plus puissant avec seulement l'accès à l'espace d'action `bash`, l'agent CodeAct exploite le système de plugins d'OpenHands:
 
-- [Plugin Jupyter](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/jupyter) : pour l'exécution d'IPython via la commande bash
-- [Plugin outil agent SWE](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/swe_agent_commands) : Outils de ligne de commande bash puissants pour les tâches de développement logiciel introduits par [swe-agent](https://github.com/princeton-nlp/swe-agent).
+- [Plugin Jupyter](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/runtime/plugins/jupyter) : pour l'exécution d'IPython via la commande bash
+- [Plugin outil agent SWE](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/runtime/plugins/swe_agent_commands) : Outils de ligne de commande bash puissants pour les tâches de développement logiciel introduits par [swe-agent](https://github.com/princeton-nlp/swe-agent).
 
 ### Démonstration
 
-https://github.com/OpenDevin/OpenDevin/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
+https://github.com/All-Hands-AI/OpenHands/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
 
 _Exemple de CodeActAgent avec `gpt-4-turbo-2024-04-09` effectuant une tâche de science des données (régression linéaire)_
 

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

@@ -25,14 +25,14 @@ _**Avertissement**: L'architecture du backend est en cours de développement et
 
     ## Prérequis
 
-    - Un environnement Python dans lequel opendevin est exécutable
+    - Un environnement Python dans lequel openhands est exécutable
     (selon les instructions du fichier README.md à la racine du dépôt)
     - [py2puml](https://github.com/lucsorel/py2puml) installé
 
 ## Étapes
 
 1.  Générez automatiquement le schéma en exécutant la commande suivante depuis la racine du dépôt :
-    `py2puml opendevin opendevin > docs/architecture/backend_architecture.puml`
+    `py2puml openhands openhands > docs/architecture/backend_architecture.puml`
 
 2.  Ouvrez le fichier généré dans un éditeur PlantUML, par exemple Visual Studio Code avec l'extension PlantUML ou [PlantText](https://www.planttext.com/)
 

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

@@ -1,14 +1,14 @@
 # 💿 Comment Créer un Soutien Docker sur Mesure
 
-Le sandbox par défaut OpenDevin est équipé d'une configuration ubuntu minimaliste. Votre cas d'utilisation pourrait nécessiter des logiciels installés par défaut. Cet article vous enseignera comment réaliser cela en utilisant une image docker personnalisée.
+Le sandbox par défaut OpenHands est équipé d'une configuration ubuntu minimaliste. Votre cas d'utilisation pourrait nécessiter des logiciels installés par défaut. Cet article vous enseignera comment réaliser cela en utilisant une image docker personnalisée.
 
 ## Configuration
 
-Assurez-vous de pouvoir utiliser OpenDevin en suivant la documentation [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md).
+Assurez-vous de pouvoir utiliser OpenHands en suivant la documentation [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
 
 ## Créer Votre Image Docker
 
-Ensuite, vous devez créer votre image docker personnalisée qui doit être basée sur debian/ubuntu. Par exemple, si nous souhaitons que OpenDevin ait accès au "node" binaire, nous utiliserions ce Dockerfile:
+Ensuite, vous devez créer votre image docker personnalisée qui doit être basée sur debian/ubuntu. Par exemple, si nous souhaitons que OpenHands ait accès au "node" binaire, nous utiliserions ce Dockerfile:
 
 ```bash
 # Commencez avec l'image ubuntu la plus récente
@@ -29,27 +29,27 @@ docker build -t image_personnalisée .
 
 Cela produira une nouvelle image appelée ```image_personnalisée``` qui sera disponible dans Docker Engine.
 
-> Remarque: Dans la configuration décrite ici, OpenDevin va fonctionner en tant que utilisateur "opendevin" à l'intérieur du sandbox et donc tous les packages installés via le Dockerfile seront disponibles pour tous les utilisateurs sur le système, pas seulement root.
+> Remarque: Dans la configuration décrite ici, OpenHands va fonctionner en tant que utilisateur "openhands" à l'intérieur du sandbox et donc tous les packages installés via le Dockerfile seront disponibles pour tous les utilisateurs sur le système, pas seulement root.
 >
 > L'installation avec apt-get ci-dessus installe nodejs pour tous les utilisateurs.
 
 ## Spécifiez votre image personnalisée dans le fichier config.toml
 
-La configuration OpenDevin se fait via le fichier de niveau supérieur ```config.toml``` .
-Créez un fichier ```config.toml``` dans le répertoire OpenDevin et entrez ces contenus:
+La configuration OpenHands se fait via le fichier de niveau supérieur ```config.toml``` .
+Créez un fichier ```config.toml``` dans le répertoire OpenHands et entrez ces contenus:
 
 ```toml
 [core]
 workspace_base="./workspace"
-run_as_devin=true
-sandbox_container_image="image_personnalisée"
+run_as_openhands=true
+sandbox_base_container_image="image_personnalisée"
 ```
 
-> Assurez-vous que ```sandbox_container_image``` est défini sur le nom de votre image personnalisée précédente.
+> Assurez-vous que ```sandbox_base_container_image``` est défini sur le nom de votre image personnalisée précédente.
 
 ## Exécution
 
-Exécutez OpenDevin en exécutant ```make run``` dans le répertoire racine.
+Exécutez OpenHands en exécutant ```make run``` dans le répertoire racine.
 
 Naviguez vers ```localhost:3001``` et vérifiez si vos dépendances souhaitées sont disponibles.
 
@@ -59,40 +59,36 @@ Félicitations !
 
 ## Explication technique
 
-Le code pertinent est défini dans [ssh_box.py](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/ssh_box.py) et [image_agnostic_util.py](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py).
-
-En particulier, ssh_box.py vérifie l'objet config pour ```config.sandbox_container_image``` et ensuite tente de récupérer l'image à l'aide de [get_od_sandbox_image](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py#L72), qui est défini dans image_agnostic_util.py.
-
 Lorsqu'une image personnalisée est utilisée pour la première fois, elle ne sera pas trouvée et donc elle sera construite (à l'exécution ultérieure, l'image construite sera trouvée et renvoyée).
 
-L'image personnalisée est construite avec [_build_sandbox_image()](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py#L29), qui crée un fichier docker en utilisant votre image personnalisée comme base et configure ensuite l'environnement pour OpenDevin, comme ceci:
+L'image personnalisée est construite avec [_build_sandbox_image()](https://github.com/All-Hands-AI/OpenHands/blob/main/openhands/runtime/docker/image_agnostic_util.py#L29), qui crée un fichier docker en utilisant votre image personnalisée comme base et configure ensuite l'environnement pour OpenHands, comme ceci:
 
 ```python
 dockerfile_content = (
         f'FROM {base_image}\n'
         'RUN apt update && apt install -y openssh-server wget sudo\n'
         'RUN mkdir -p -m0755 /var/run/sshd\n'
-        'RUN mkdir -p /opendevin && mkdir -p /opendevin/logs && chmod 777 /opendevin/logs\n'
+        'RUN mkdir -p /openhands && mkdir -p /openhands/logs && chmod 777 /openhands/logs\n'
         'RUN wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"\n'
-        'RUN bash Miniforge3-$(uname)-$(uname -m).sh -b -p /opendevin/miniforge3\n'
-        'RUN bash -c ". /opendevin/miniforge3/etc/profile.d/conda.sh && conda config --set changeps1 False && conda config --append channels conda-forge"\n'
-        'RUN echo "export PATH=/opendevin/miniforge3/bin:$PATH" >> ~/.bashrc\n'
-        'RUN echo "export PATH=/opendevin/miniforge3/bin:$PATH" >> /opendevin/bash.bashrc\n'
+        'RUN bash Miniforge3-$(uname)-$(uname -m).sh -b -p /openhands/miniforge3\n'
+        'RUN bash -c ". /openhands/miniforge3/etc/profile.d/conda.sh && conda config --set changeps1 False && conda config --append channels conda-forge"\n'
+        'RUN echo "export PATH=/openhands/miniforge3/bin:$PATH" >> ~/.bashrc\n'
+        'RUN echo "export PATH=/openhands/miniforge3/bin:$PATH" >> /openhands/bash.bashrc\n'
     ).strip()
 ```
 
-> Remarque: Le nom de l'image est modifié via [_get_new_image_name()](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py#L63) et c'est ce nom modifié qui sera recherché lors des exécutions ultérieures.
+> Remarque: Le nom de l'image est modifié via [_get_new_image_name()](https://github.com/All-Hands-AI/OpenHands/blob/main/openhands/runtime/docker/image_agnostic_util.py#L63) et c'est ce nom modifié qui sera recherché lors des exécutions ultérieures.
 
 ## 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 OpenDevin essaie de créer le utilisateur opendevin 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 sandbox_user_id dans le fichier config.toml en une valeur différente:
 
 ```toml
 [core]
 workspace_base="./workspace"
-run_as_devin=true
-sandbox_container_image="image_personnalisée"
+run_as_openhands=true
+sandbox_base_container_image="image_personnalisée"
 sandbox_user_id="1001"
 ```
 
@@ -102,4 +98,4 @@ Si vous voyez un message d'erreur indiquant que le port est utilisé ou indispon
 
 ## Discuter
 
-Pour d'autres problèmes ou questions rejoignez le [Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw) ou le [Discord](https://discord.gg/ESHStjSjD4) et demandez!
+Pour d'autres problèmes ou questions rejoignez le [Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA) ou le [Discord](https://discord.gg/ESHStjSjD4) et demandez!

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

@@ -4,15 +4,15 @@ sidebar_position: 6
 
 # ✅ Fournir des Commentaires
 
-Lorsque vous utilisez OpenDevin, vous rencontrerez sans aucun doute des cas où les choses fonctionnent bien et d'autres où elles ne fonctionnent pas. Nous vous encourageons à fournir des commentaires lorsque vous utilisez OpenDevin pour aider l'équipe de développement et, peut-être plus important encore, créer un corpus ouvert d'exemples de formation pour les agents de codage -- Partagez-OpenDevin !
+Lorsque vous utilisez OpenHands, vous rencontrerez sans aucun doute des cas où les choses fonctionnent bien et d'autres où elles ne fonctionnent pas. Nous vous encourageons à fournir des commentaires lorsque vous utilisez OpenHands pour aider l'équipe de développement et, peut-être plus important encore, créer un corpus ouvert d'exemples de formation pour les agents de codage -- Partagez-OpenHands !
 
 ## 📝 Comment Fournir des Commentaires
 
-Fournir des commentaires est simple ! Lorsque vous utilisez OpenDevin, vous pouvez appuyer sur le bouton de pouce vers le haut ou vers le bas à n'importe quel moment de votre interaction. Vous serez invité à fournir votre adresse email (par exemple, afin que nous puissions vous contacter si nous voulons poser des questions de suivi), et vous pouvez choisir si vous souhaitez fournir des commentaires publiquement ou en privé.
+Fournir des commentaires est simple ! Lorsque vous utilisez OpenHands, vous pouvez appuyer sur le bouton de pouce vers le haut ou vers le bas à n'importe quel moment de votre interaction. Vous serez invité à fournir votre adresse email (par exemple, afin que nous puissions vous contacter si nous voulons poser des questions de suivi), et vous pouvez choisir si vous souhaitez fournir des commentaires publiquement ou en privé.
 
 <iframe width="560" height="315" src="https://www.youtube.com/embed/5rFx-StMVV0?si=svo7xzp6LhGK_GXr" title="Lecteur vidéo YouTube" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
 
 ## 📜 Licence de Données et Confidentialité
 
-* Les données **publiques** seront distribuées sous la licence MIT, comme OpenDevin lui-même, et pourront être utilisées par la communauté pour former et tester des modèles. Évidemment, les commentaires que vous pouvez rendre publics seront plus précieux pour la communauté dans son ensemble, donc lorsque vous ne traitez pas d'informations sensibles, nous vous encourageons à choisir cette option !
-* Les données **privées** ne seront partagées qu'avec l'équipe OpenDevin dans le but d'améliorer OpenDevin.
+* Les données **publiques** seront distribuées sous la licence MIT, comme OpenHands lui-même, et pourront être utilisées par la communauté pour former et tester des modèles. Évidemment, les commentaires que vous pouvez rendre publics seront plus précieux pour la communauté dans son ensemble, donc lorsque vous ne traitez pas d'informations sensibles, nous vous encourageons à choisir cette option !
+* Les données **privées** ne seront partagées qu'avec l'équipe OpenHands dans le but d'améliorer OpenHands.

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

@@ -2,47 +2,47 @@
 sidebar_position: 1
 ---
 
-# 💻 OpenDevin
+# 💻 OpenHands
 
-OpenDevin est un **ingénieur logiciel IA autonome** capable d'exécuter des tâches d'ingénierie complexes et de collaborer activement avec les utilisateurs sur des projets de développement logiciel.
+OpenHands est un **ingénieur logiciel IA autonome** capable d'exécuter des tâches d'ingénierie complexes et de collaborer activement avec les utilisateurs sur des projets de développement logiciel.
 Ce projet est entièrement open-source, vous pouvez donc l'utiliser et le modifier comme bon vous semble.
 
 :::tip
-Explorez le code source d'OpenDevin sur [GitHub](https://github.com/OpenDevin/OpenDevin) ou rejoignez l'une de nos communautés !
+Explorez le code source d'OpenHands sur [GitHub](https://github.com/All-Hands-AI/OpenHands) ou rejoignez l'une de nos communautés !
 
-<a href="https://github.com/OpenDevin/OpenDevin/graphs/contributors">
+<a href="https://github.com/All-Hands-AI/OpenHands/graphs/contributors">
   <img
-    src="https://img.shields.io/github/contributors/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/contributors/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Contributors"
   />
 </a>
-<a href="https://github.com/OpenDevin/OpenDevin/network/members">
+<a href="https://github.com/All-Hands-AI/OpenHands/network/members">
   <img
-    src="https://img.shields.io/github/forks/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/forks/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Forks"
   />
 </a>
-<a href="https://github.com/OpenDevin/OpenDevin/stargazers">
+<a href="https://github.com/All-Hands-AI/OpenHands/stargazers">
   <img
-    src="https://img.shields.io/github/stars/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/stars/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Stargazers"
   />
 </a>
-<a href="https://github.com/OpenDevin/OpenDevin/issues">
+<a href="https://github.com/All-Hands-AI/OpenHands/issues">
   <img
-    src="https://img.shields.io/github/issues/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/issues/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Issues"
   />
 </a>
 <br></br>
-<a href="https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE">
+<a href="https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE">
   <img
-    src="https://img.shields.io/github/license/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/license/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="MIT License"
   />
 </a>
 <br></br>
-<a href="https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw">
+<a href="https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA">
   <img
     src="https://img.shields.io/badge/Slack-Join%20Us-red?logo=slack&logoColor=white&style=for-the-badge"
     alt="Join our Slack community"
@@ -58,10 +58,10 @@ Explorez le code source d'OpenDevin sur [GitHub](https://github.com/OpenDevin/Op
 
 ## 🛠️ Pour commencer
 
-La manière la plus simple d'exécuter OpenDevin est à l'intérieur d'un conteneur Docker. Il fonctionne mieux avec la version la plus récente de Docker, `26.0.0`.
+La manière la plus simple d'exécuter OpenHands est à l'intérieur d'un conteneur Docker. Il fonctionne mieux avec la version la plus récente de Docker, `26.0.0`.
 Vous devez utiliser Linux, Mac OS ou WSL sur Windows.
 
-Pour démarrer OpenDevin dans un conteneur docker, exécutez les commandes suivantes dans votre terminal :
+Pour démarrer OpenHands dans un conteneur docker, exécutez les commandes suivantes dans votre terminal :
 
 :::warning
 Lorsque vous exécutez la commande suivante, les fichiers dans `./workspace` peuvent être modifiés ou supprimés.
@@ -77,33 +77,33 @@ docker run -it \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
-    --name opendevin-app-$(date +%Y%m%d%H%M%S) \
-    ghcr.io/opendevin/opendevin:0.6
+    --name openhands-app-$(date +%Y%m%d%H%M%S) \
+    ghcr.io/all-hands-ai/openhands:main
 ```
 
-Vous trouverez OpenDevin fonctionnant à l'adresse [http://localhost:3000](http://localhost:3000) avec accès à `./workspace`. Pour qu'OpenDevin fonctionne sur votre code, placez-le dans `./workspace`.
+Vous trouverez OpenHands fonctionnant à l'adresse [http://localhost:3000](http://localhost:3000) avec accès à `./workspace`. Pour qu'OpenHands fonctionne sur votre code, placez-le dans `./workspace`.
 
-OpenDevin n'aura accès qu'à ce dossier de workspace. Le reste de votre système ne sera pas affecté car il s'exécute dans un bac à sable sécurisé de docker.
+OpenHands n'aura accès qu'à ce dossier de workspace. Le reste de votre système ne sera pas affecté car il s'exécute dans un bac à sable sécurisé de docker.
 
 :::tip
-Si vous souhaitez utiliser la version **(instable !)** la plus récente, vous pouvez utiliser `ghcr.io/opendevin/opendevin:main` comme image (dernière ligne).
+Si vous souhaitez utiliser la version **(instable !)** la plus récente, vous pouvez utiliser `ghcr.io/all-hands-ai/openhands:main` comme image (dernière ligne).
 :::
 
-Pour le workflow de développement, consultez [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md).
+Pour le workflow de développement, consultez [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md).
 
 Avez-vous des problèmes ? Consultez notre [Guide de dépannage](https://docs.all-hands.dev/modules/usage/troubleshooting).
 
 :::warning
-OpenDevin est actuellement en cours de développement, mais vous pouvez déjà exécuter la version alpha pour voir le système de bout en bout en action.
+OpenHands est actuellement en cours de développement, mais vous pouvez déjà exécuter la version alpha pour voir le système de bout en bout en action.
 :::
 
-[contributors-shield]: https://img.shields.io/github/contributors/opendevin/opendevin?style=for-the-badge
-[contributors-url]: https://github.com/OpenDevin/OpenDevin/graphs/contributors
-[forks-shield]: https://img.shields.io/github/forks/opendevin/opendevin?style=for-the-badge
-[forks-url]: https://github.com/OpenDevin/OpenDevin/network/members
-[stars-shield]: https://img.shields.io/github/stars/opendevin/opendevin?style=for-the-badge
-[stars-url]: https://github.com/OpenDevin/OpenDevin/stargazers
-[issues-shield]: https://img.shields.io/github/issues/opendevin/opendevin?style=for-the-badge
-[issues-url]: https://github.com/OpenDevin/OpenDevin/issues
-[license-shield]: https://img.shields.io/github/license/opendevin/opendevin?style=for-the-badge
-[license-url]: https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE
+[contributors-shield]: https://img.shields.io/github/contributors/All-Hands-AI/OpenHands?style=for-the-badge
+[contributors-url]: https://github.com/All-Hands-AI/OpenHands/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/All-Hands-AI/OpenHands?style=for-the-badge
+[forks-url]: https://github.com/All-Hands-AI/OpenHands/network/members
+[stars-shield]: https://img.shields.io/github/stars/All-Hands-AI/OpenHands?style=for-the-badge
+[stars-url]: https://github.com/All-Hands-AI/OpenHands/stargazers
+[issues-shield]: https://img.shields.io/github/issues/All-Hands-AI/OpenHands?style=for-the-badge
+[issues-url]: https://github.com/All-Hands-AI/OpenHands/issues
+[license-shield]: https://img.shields.io/github/license/All-Hands-AI/OpenHands?style=for-the-badge
+[license-url]: https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE

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

@@ -2,11 +2,11 @@
 
 ## Complétion
 
-OpenDevin utilise LiteLLM pour les appels de complétion. Vous pouvez trouver leur documentation sur Azure [ici](https://docs.litellm.ai/docs/providers/azure)
+OpenHands utilise LiteLLM pour les appels de complétion. Vous pouvez trouver leur documentation sur Azure [ici](https://docs.litellm.ai/docs/providers/azure)
 
 ### Configurations openai Azure
 
-Lors de l'exécution de l'image Docker OpenDevin, vous devrez définir les variables d'environnement suivantes en utilisant `-e` :
+Lors de l'exécution de l'image Docker OpenHands, vous devrez définir les variables d'environnement suivantes en utilisant `-e` :
 
 ```
 LLM_BASE_URL="<azure-api-base-url>"          # e.g. "https://openai-gpt-4-test-v-1.openai.azure.com/"
@@ -16,19 +16,19 @@ LLM_API_VERSION = "<api-version>"          # e.g. "2024-02-15-preview"
 ```
 
 :::note
-Vous pouvez trouver le nom de votre déploiement ChatGPT sur la page des déploiements sur Azure. Par défaut ou initialement, il pourrait être le même que le nom du modèle de chat (par exemple 'GPT4-1106-preview'), mais il n'est pas obligé de l'être. Exécutez OpenDevin, et une fois chargé dans le navigateur, allez dans Paramètres et définissez le modèle comme suit : "azure/&lt;your-actual-gpt-deployment-name&gt;". Si ce n'est pas dans la liste, entrez votre propre texte et enregistrez-le.
+Vous pouvez trouver le nom de votre déploiement ChatGPT sur la page des déploiements sur Azure. Par défaut ou initialement, il pourrait être le même que le nom du modèle de chat (par exemple 'GPT4-1106-preview'), mais il n'est pas obligé de l'être. Exécutez OpenHands, et une fois chargé dans le navigateur, allez dans Paramètres et définissez le modèle comme suit : "azure/&lt;your-actual-gpt-deployment-name&gt;". Si ce n'est pas dans la liste, entrez votre propre texte et enregistrez-le.
 :::
 
 ## Embeddings
 
-OpenDevin utilise llama-index pour les embeddings. Vous pouvez trouver leur documentation sur Azure [ici](https://docs.llamaindex.ai/en/stable/api_reference/embeddings/azure_openai/)
+OpenHands utilise llama-index pour les embeddings. Vous pouvez trouver leur documentation sur Azure [ici](https://docs.llamaindex.ai/en/stable/api_reference/embeddings/azure_openai/)
 
 ### Configurations openai Azure
 
 Le modèle utilisé pour les embeddings Azure OpenAI est "text-embedding-ada-002".
 Vous avez besoin du nom de déploiement correct pour ce modèle dans votre compte Azure.
 
-Lors de l'exécution d'OpenDevin dans Docker, définissez les variables d'environnement suivantes en utilisant `-e` :
+Lors de l'exécution d'OpenHands dans Docker, définissez les variables d'environnement suivantes en utilisant `-e` :
 
 ```
 LLM_EMBEDDING_MODEL="azureopenai"

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

@@ -2,14 +2,14 @@
 
 ## Complétion
 
-OpenDevin utilise LiteLLM pour les appels de complétion. Les ressources suivantes sont pertinentes pour utiliser OpenDevin avec les LLMs de Google :
+OpenHands utilise LiteLLM pour les appels de complétion. Les ressources suivantes sont pertinentes pour utiliser OpenHands avec les LLMs de Google :
 
 - [Gemini - Google AI Studio](https://docs.litellm.ai/docs/providers/gemini)
 - [VertexAI - Google Cloud Platform](https://docs.litellm.ai/docs/providers/vertex)
 
 ### Configurations de Gemini - Google AI Studio
 
-Pour utiliser Gemini via Google AI Studio lors de l'exécution de l'image Docker d'OpenDevin, vous devez définir les variables d'environnement suivantes en utilisant `-e` :
+Pour utiliser Gemini via Google AI Studio lors de l'exécution de l'image Docker d'OpenHands, vous devez définir les variables d'environnement suivantes en utilisant `-e` :
 
 ```
 GEMINI_API_KEY="<votre-cle-api-google>"
@@ -18,7 +18,7 @@ LLM_MODEL="gemini/gemini-1.5-pro"
 
 ### Configurations de Vertex AI - Google Cloud Platform
 
-Pour utiliser Vertex AI via Google Cloud Platform lors de l'exécution de l'image Docker d'OpenDevin, vous devez définir les variables d'environnement suivantes en utilisant `-e` :
+Pour utiliser Vertex AI via Google Cloud Platform lors de l'exécution de l'image Docker d'OpenHands, vous devez définir les variables d'environnement suivantes en utilisant `-e` :
 
 ```
 GOOGLE_APPLICATION_CREDENTIALS="<dump-json-du-compte-de-service-gcp-json>"

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

@@ -4,16 +4,16 @@ sidebar_position: 2
 
 # 🤖 Backends LLM
 
-OpenDevin peut fonctionner avec n'importe quel backend LLM.
+OpenHands peut fonctionner avec n'importe quel backend LLM.
 Pour une liste complète des fournisseurs et des modèles LM disponibles, veuillez consulter la
 [documentation litellm](https://docs.litellm.ai/docs/providers).
 
 :::warning
-OpenDevin émettra de nombreuses invitations au LLM que vous configurez. La plupart de ces LLM coûtent de l'argent -- assurez-vous de définir des limites de dépenses et de surveiller l'utilisation.
+OpenHands émettra de nombreuses invitations au LLM que vous configurez. La plupart de ces LLM coûtent de l'argent -- assurez-vous de définir des limites de dépenses et de surveiller l'utilisation.
 :::
 
 La variable d'environnement `LLM_MODEL` contrôle le modèle utilisé dans les interactions programmatiques.
-Mais en utilisant l'interface utilisateur OpenDevin, vous devrez choisir votre modèle dans la fenêtre des paramètres (la roue dentée en bas à gauche).
+Mais en utilisant l'interface utilisateur OpenHands, vous devrez choisir votre modèle dans la fenêtre des paramètres (la roue dentée en bas à gauche).
 
 Les variables d'environnement suivantes peuvent être nécessaires pour certains LLM :
 
@@ -23,10 +23,10 @@ Les variables d'environnement suivantes peuvent être nécessaires pour certains
 - `LLM_EMBEDDING_DEPLOYMENT_NAME`
 - `LLM_API_VERSION`
 
-Nous avons quelques guides pour exécuter OpenDevin avec des fournisseurs de modèles spécifiques :
+Nous avons quelques guides pour exécuter OpenHands avec des fournisseurs de modèles spécifiques :
 
-- [ollama](llms/localLLMs)
-- [Azure](llms/azureLLMs)
+- [ollama](llms/local-llms)
+- [Azure](llms/azure-llms)
 
 Si vous utilisez un autre fournisseur, nous vous encourageons à ouvrir une PR pour partager votre configuration !
 
@@ -34,11 +34,11 @@ Si vous utilisez un autre fournisseur, nous vous encourageons à ouvrir une PR p
 
 Les meilleurs modèles sont GPT-4 et Claude 3. Les modèles locaux et open source actuels ne sont pas aussi puissants.
 Lors de l'utilisation d'un modèle alternatif, vous pouvez constater des temps d'attente prolongés entre les messages,
-des réponses de mauvaise qualité ou des erreurs sur des JSON mal formés. OpenDevin
+des réponses de mauvaise qualité ou des erreurs sur des JSON mal formés. OpenHands
 ne peut être aussi puissant que les modèles qui le pilotent -- heureusement, les membres de notre équipe travaillent activement à la construction de meilleurs modèles open source !
 
 ## Réessais d'API et limites de taux
 
-Certains LLM ont des limites de taux et peuvent nécessiter des réessais. OpenDevin réessaiera automatiquement les demandes s'il reçoit une erreur 429 ou une erreur de connexion API.
+Certains LLM ont des limites de taux et peuvent nécessiter des réessais. OpenHands réessaiera automatiquement les demandes s'il reçoit une erreur 429 ou une erreur de connexion API.
 Vous pouvez définir les variables d'environnement `LLM_NUM_RETRIES`, `LLM_RETRY_MIN_WAIT`, `LLM_RETRY_MAX_WAIT` pour contrôler le nombre de réessais et le temps entre les réessais.
-Par défaut, `LLM_NUM_RETRIES` est 5 et `LLM_RETRY_MIN_WAIT`, `LLM_RETRY_MAX_WAIT` sont respectivement de 3 secondes et 60 secondes.
+Par défaut, `LLM_NUM_RETRIES` est 8 et `LLM_RETRY_MIN_WAIT`, `LLM_RETRY_MAX_WAIT` sont respectivement de 15 secondes et 120 secondes.

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

@@ -24,11 +24,11 @@ mistral:7b-instruct-v0.2-q4_K_M eb14864c7427    4.4 GB  2 weeks ago
 starcoder2:latest               f67ae0f64584    1.7 GB  19 hours ago
 ```
 
-## Démarrer OpenDevin
+## Démarrer OpenHands
 
 ### Docker
 
-Utilisez les instructions [ici](../intro) pour démarrer OpenDevin en utilisant Docker.
+Utilisez les instructions [ici](../intro) pour démarrer OpenHands en utilisant Docker.
 Mais lors de l'exécution de `docker run`, vous devrez ajouter quelques arguments supplémentaires :
 
 ```bash
@@ -40,7 +40,7 @@ Mais lors de l'exécution de `docker run`, vous devrez ajouter quelques argument
 Par exemple :
 
 ```bash
-# Le répertoire que vous souhaitez qu'OpenDevin modifie. DOIT être un chemin absolu !
+# Le répertoire que vous souhaitez qu'OpenHands modifie. DOIT être un chemin absolu !
 export WORKSPACE_BASE=$(pwd)/workspace
 
 docker run \
@@ -54,14 +54,14 @@ docker run \
     -v $WORKSPACE_BASE:/opt/workspace_base \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -p 3000:3000 \
-    ghcr.io/opendevin/opendevin:main
+    ghcr.io/all-hands-ai/openhands:main
 ```
 
 Vous devriez maintenant pouvoir vous connecter à `http://localhost:3000/`
 
 ### Compiler à partir des sources
 
-Utilisez les instructions dans [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md) pour compiler OpenDevin.
+Utilisez les instructions dans [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md) pour compiler OpenHands.
 Assurez-vous que `config.toml` soit présent en exécutant `make setup-config` qui en créera un pour vous. Dans `config.toml`, saisissez les éléments suivants :
 
 ```
@@ -75,11 +75,11 @@ WORKSPACE_DIR="$(pwd)/workspace"
 
 Remplacez `LLM_MODEL` par celui de votre choix si nécessaire.
 
-Fini ! Vous pouvez maintenant démarrer Devin avec : `make run` sans Docker. Vous devriez maintenant pouvoir vous connecter à `http://localhost:3000/`
+Fini ! Vous pouvez maintenant démarrer OpenHands avec : `make run` sans Docker. Vous devriez maintenant pouvoir vous connecter à `http://localhost:3000/`
 
 ## Sélection de votre modèle
 
-Dans l'interface OpenDevin, cliquez sur l'icône des paramètres en bas à gauche.
+Dans l'interface OpenHands, cliquez sur l'icône des paramètres en bas à gauche.
 Ensuite, dans l'entrée `Model`, saisissez `ollama/codellama:7b`, ou le nom du modèle que vous avez téléchargé précédemment.
 S'il n'apparaît pas dans un menu déroulant, ce n'est pas grave, tapez-le simplement. Cliquez sur Enregistrer lorsque vous avez terminé.
 
@@ -87,7 +87,7 @@ Et maintenant, vous êtes prêt à démarrer !
 
 ## Configuration du service ollama (WSL){#configuring-ollama-service-fr}
 
-La configuration par défaut pour ollama sous WSL ne sert que localhost. Cela signifie que vous ne pouvez pas l'atteindre depuis un conteneur docker, par exemple, il ne fonctionnera pas avec OpenDevin. Testons d'abord que ollama est en cours d'exécution correctement.
+La configuration par défaut pour ollama sous WSL ne sert que localhost. Cela signifie que vous ne pouvez pas l'atteindre depuis un conteneur docker, par exemple, il ne fonctionnera pas avec OpenHands. Testons d'abord que ollama est en cours d'exécution correctement.
 
 ```bash
 ollama list # obtenir la liste des modèles installés
@@ -99,7 +99,7 @@ curl http://localhost:11434/api/generate -d '{"model":"[NAME]","prompt":"hi"}'
 Une fois cela fait, testez qu'il accepte les requêtes "externes", comme celles provenant d'un conteneur docker.
 
 ```bash
-docker ps # obtenir la liste des conteneurs docker en cours d'exécution, pour un test le plus précis choisissez le conteneur de sandbox open devin.
+docker ps # obtenir la liste des conteneurs docker en cours d'exécution, pour un test le plus précis choisissez le conteneur de sandbox OpenHands.
 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"}'
 ```
@@ -136,6 +136,6 @@ Enfin, testez que ollama est accessible depuis le conteneur
 
 ```bash
 ollama list # obtenir la liste des modèles installés
-docker ps # obtenir la liste des conteneurs docker en cours d'exécution, pour un test le plus précis choisissez le conteneur de sandbox open devin.
+docker ps # obtenir la liste des conteneurs docker en cours d'exécution, pour un test le plus précis choisissez le conteneur de sandbox OpenHands.
 docker exec [CONTAINER ID] curl http://host.docker.internal:11434/api/generate -d '{"model":"[NAME]","prompt":"hi"}'
 ```

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

@@ -20,7 +20,7 @@ Si vous utilisez Windows et que vous rencontrez des problèmes, consultez notre
 
 ## Impossible de se connecter à Docker
 
-[Problème GitHub](https://github.com/OpenDevin/OpenDevin/issues/1226)
+[Problème GitHub](https://github.com/All-Hands-AI/OpenHands/issues/1226)
 
 ### Symptômes
 
@@ -34,7 +34,7 @@ docker.errors.DockerException: Erreur lors de la récupération de la version de
 
 ### Détails
 
-OpenDevin utilise un conteneur Docker pour effectuer son travail en toute sécurité, sans risquer de briser votre machine.
+OpenHands utilise un conteneur Docker pour effectuer son travail en toute sécurité, sans risquer de briser votre machine.
 
 ### Solutions de contournement
 
@@ -45,7 +45,7 @@ OpenDevin utilise un conteneur Docker pour effectuer son travail en toute sécur
 
 ## Impossible de se connecter à la boîte SSH
 
-[Problème GitHub](https://github.com/OpenDevin/OpenDevin/issues/1156)
+[Problème GitHub](https://github.com/All-Hands-AI/OpenHands/issues/1156)
 
 ### Symptômes
 
@@ -57,7 +57,7 @@ pexpect.pxssh.ExceptionPxssh: Impossible d'établir une connexion avec l'hôte
 
 ### Détails
 
-Par défaut, OpenDevin se connecte à un conteneur en cours d'exécution via SSH. Sur certaines machines,
+Par défaut, OpenHands se connecte à un conteneur en cours d'exécution via SSH. Sur certaines machines,
 en particulier Windows, cela semble échouer.
 
 ### Solutions de contournement
@@ -65,11 +65,11 @@ en particulier Windows, cela semble échouer.
 * Redémarrez votre ordinateur (parfois cela fonctionne)
 * Assurez-vous d'avoir les dernières versions de WSL et Docker
 * Vérifiez que votre distribution dans WSL est également à jour
-* Essayez [ce guide de réinstallation](https://github.com/OpenDevin/OpenDevin/issues/1156#issuecomment-2064549427)
+* Essayez [ce guide de réinstallation](https://github.com/All-Hands-AI/OpenHands/issues/1156#issuecomment-2064549427)
 
 ## Impossible de se connecter à LLM
 
-[Problème GitHub](https://github.com/OpenDevin/OpenDevin/issues/1208)
+[Problème GitHub](https://github.com/All-Hands-AI/OpenHands/issues/1208)
 
 ### Symptômes
 
@@ -82,10 +82,10 @@ AttributeError: 'NoneType' object has no attribute 'request'
 
 ### Détails
 
-[Problèmes GitHub](https://github.com/OpenDevin/OpenDevin/issues?q=is%3Aissue+is%3Aopen+404)
+[Problèmes GitHub](https://github.com/All-Hands-AI/OpenHands/issues?q=is%3Aissue+is%3Aopen+404)
 
-Cela se produit généralement avec les configurations de LLM *locales*, lorsque OpenDevin ne parvient pas à se connecter au serveur LLM.
-Consultez notre guide pour [LLMs locaux](llms/localLLMs) pour plus d'informations.
+Cela se produit généralement avec les configurations de LLM *locales*, lorsque OpenHands ne parvient pas à se connecter au serveur LLM.
+Consultez notre guide pour [LLMs locaux](llms/local-llms) pour plus d'informations.
 
 ### Solutions de contournement
 
@@ -133,9 +133,9 @@ le point de terminaison API avec lequel vous essayez de vous connecter. Cela arr
   * Si vous êtes en cours d'exécution dans l'interface utilisateur, assurez-vous de définir le `model` dans le modal des paramètres
   * Si vous êtes en cours d'exécution sans interface (via main.py), assurez-vous de définir `LLM_MODEL` dans votre env/config
 * Assurez-vous de suivre les instructions spéciales de votre fournisseur de LLM
-  * [ollama](/fr/modules/usage/llms/localLLMs)
-  * [Azure](/fr/modules/usage/llms/azureLLMs)
-  * [Google](/fr/modules/usage/llms/googleLLMs)
+  * [ollama](/fr/modules/usage/llms/local-llms)
+  * [Azure](/fr/modules/usage/llms/azure-llms)
+  * [Google](/fr/modules/usage/llms/google-llms)
 * Assurez-vous que votre clé API est correcte
 * Voyez si vous pouvez vous connecter au LLM en utilisant `curl`
 * Essayez de [vous connecter via LiteLLM directement](https://github.com/BerriAI/litellm) pour tester votre configuration
@@ -179,24 +179,24 @@ export PYTHON_KEYRING_BACKEND=keyring.backends.null.Keyring
 
 ### Symptômes
 
-OpenDevin demande généralement s'il faut reprendre ou commencer une nouvelle session lors de l'ouverture de l'interface utilisateur.
+OpenHands demande généralement s'il faut reprendre ou commencer une nouvelle session lors de l'ouverture de l'interface utilisateur.
 Mais cliquer sur "Reprendre" démarre toujours une toute nouvelle discussion.
 
 ### Détails
 
 Avec une installation standard à ce jour, les données de session sont stockées en mémoire.
-Actuellement, si le service OpenDevin est redémarré, les sessions précédentes deviennent
+Actuellement, si le service OpenHands est redémarré, les sessions précédentes deviennent
 invalides (un nouveau secret est généré) et donc non récupérables.
 
 ### Solutions de contournement
 
 * Modifiez la configuration pour rendre les sessions persistantes en éditant le fichier `config.toml`
-(dans le dossier racine d'OpenDevin) en spécifiant un `file_store` et un
+(dans le dossier racine d'OpenHands) en spécifiant un `file_store` et un
 `file_store_path` absolu :
 
 ```toml
 file_store="local"
-file_store_path="/absolute/path/to/opendevin/cache/directory"
+file_store_path="/absolute/path/to/openhands/cache/directory"
 ```
 
 * Ajoutez un secret jwt fixe dans votre .bashrc, comme ci-dessous, afin que les id de session précédents

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

@@ -1,6 +1,6 @@
 # Notes pour les utilisateurs de Windows et WSL
 
-OpenDevin ne supporte Windows que via [WSL](https://learn.microsoft.com/en-us/windows/wsl/install).
+OpenHands ne supporte Windows que via [WSL](https://learn.microsoft.com/en-us/windows/wsl/install).
 Veuillez vous assurer de lancer toutes les commandes à l'intérieur de votre terminal WSL.
 
 ## Dépannage
@@ -12,8 +12,8 @@ Docker doit également avoir l'option d'intégration WSL activée.
 
 ### Recommandation : Ne pas exécuter en tant qu'utilisateur root
 
-Pour des raisons de sécurité, il est fortement recommandé de ne pas exécuter OpenDevin en tant qu'utilisateur root, mais en tant qu'utilisateur avec un UID non nul.
-De plus, les sandboxes persistants ne seront pas pris en charge lors de l'exécution en tant que root et un message approprié pourrait apparaître lors du démarrage d'OpenDevin.
+Pour des raisons de sécurité, il est fortement recommandé de ne pas exécuter OpenHands en tant qu'utilisateur root, mais en tant qu'utilisateur avec un UID non nul.
+De plus, les sandboxes persistants ne seront pas pris en charge lors de l'exécution en tant que root et un message approprié pourrait apparaître lors du démarrage d'OpenHands.
 
 Références :
 
@@ -21,12 +21,12 @@ Références :
 * [Définir l'utilisateur par défaut dans WSL](https://www.tenforums.com/tutorials/128152-set-default-user-windows-subsystem-linux-distro-windows-10-a.html#option2)
 Astuce pour la 2e référence : pour les utilisateurs d'Ubuntu, la commande pourrait en fait être "ubuntupreview" au lieu de "ubuntu".
 
-### Échec de la création de l'utilisateur opendevin
+### Échec de la création de l'utilisateur openhands
 
 Si vous rencontrez l'erreur suivante lors de l'installation :
 
 ```sh
-Exception: Failed to create opendevin user in sandbox: 'useradd: UID 0 is not unique'
+Exception: Failed to create openhands user in sandbox: 'useradd: UID 0 is not unique'
 ```
 
 Vous pouvez la résoudre en exécutant :

docs/i18n/fr/docusaurus-theme-classic/navbar.json

@@ -1,10 +1,10 @@
 {
   "title": {
-    "message": "OpenDevin",
+    "message": "OpenHands",
     "description": "The title in the navbar"
   },
   "logo.alt": {
-    "message": "OpenDevin",
+    "message": "OpenHands",
     "description": "The alt text of navbar logo"
   },
   "item.label.Docs": {

docs/i18n/zh-Hans/code.json

@@ -1,6 +1,6 @@
 {
   "footer.title": {
-    "message": "OpenDevin"
+    "message": "OpenHands"
   },
   "footer.docs": {
     "message": "文档"
@@ -9,7 +9,7 @@
     "message": "社区"
   },
   "footer.copyright": {
-    "message": "版权所有 © {year} OpenDevin"
+    "message": "版权所有 © {year} OpenHands"
   },
   "faq.title": {
     "message": "常见问题解答",
@@ -19,20 +19,20 @@
     "message": "常见问题解答"
   },
   "faq.section.title.1": {
-    "message": "什么是OpenDevin？",
+    "message": "什么是OpenHands？",
     "description": "First Section Title"
   },
   "faq.section.highlight": {
-    "message": "OpenDevin",
+    "message": "OpenHands",
     "description": "Highlight Text"
   },
   "faq.section.description.1": {
-    "message": "是一个自主的软件工程师，能够端到端地解决软件工程和网页浏览任务。它能执行数据科学查询，如 \"查找上个月OpenDevin仓库中的拉取请求数量\"，还能处理软件工程任务，例如 \"请为这个文件添加测试并验证所有测试都通过，如果没有修复该文件\"。",
-    "description": "Description for OpenDevin"
+    "message": "是一个自主的软件工程师，能够端到端地解决软件工程和网页浏览任务。它能执行数据科学查询，如 \"查找上个月OpenHands仓库中的拉取请求数量\"，还能处理软件工程任务，例如 \"请为这个文件添加测试并验证所有测试都通过，如果没有修复该文件\"。",
+    "description": "Description for OpenHands"
   },
   "faq.section.description.2": {
-    "message": "同时，OpenDevin是一个代理开发者平台和社区，用于测试和评估新代理的环境。",
-    "description": "Further Description for OpenDevin"
+    "message": "同时，OpenHands是一个代理开发者平台和社区，用于测试和评估新代理的环境。",
+    "description": "Further Description for OpenHands"
   },
   "faq.section.title.2": {
     "message": "支持",
@@ -43,15 +43,15 @@
     "description": "Support Answer"
   },
   "faq.section.title.3": {
-    "message": "如何使用OpenDevin解决GitHub上的问题？",
+    "message": "如何使用OpenHands解决GitHub上的问题？",
     "description": "GitHub Issue Section Title"
   },
   "faq.section.github.steps.intro": {
-    "message": "要通过OpenDevin解决GitHub上的问题，您可以发送一个提示给OpenDevin，请它按照以下步骤操作：",
+    "message": "要通过OpenHands解决GitHub上的问题，您可以发送一个提示给OpenHands，请它按照以下步骤操作：",
     "description": "GitHub Steps Introduction"
   },
   "faq.section.github.step1": {
-    "message": "阅读问题 https://github.com/OpenDevin/OpenDevin/issues/1611",
+    "message": "阅读问题 https://github.com/All-Hands-AI/OpenHands/issues/1611",
     "description": "GitHub Step 1"
   },
   "faq.section.github.step2": {
@@ -71,11 +71,11 @@
     "description": "GitHub Step 5"
   },
   "faq.section.github.steps.preRun": {
-    "message": "在运行OpenDevin之前，您可以：",
+    "message": "在运行OpenHands之前，您可以：",
     "description": "GitHub Steps Pre-Run"
   },
   "faq.section.github.steps.tokenInfo": {
-    "message": "其中XXX是您创建的一个具有对OpenDevin仓库写权限的GitHub令牌。如果您的写入权限不足，请将其更改为：",
+    "message": "其中XXX是您创建的一个具有对OpenHands仓库写权限的GitHub令牌。如果您的写入权限不足，请将其更改为：",
     "description": "GitHub Steps Token Info"
   },
   "faq.section.github.steps.usernameInfo": {
@@ -83,23 +83,23 @@
     "description": "GitHub Steps Username Info"
   },
   "faq.section.title.4": {
-    "message": "OpenDevin与Devin有何不同？",
+    "message": "OpenHands与Devin有何不同？",
     "description": "Devin Section Title"
   },
-  "faq.section.devin.linkText": {
+  "faq.section.openhands.linkText": {
     "message": "Devin",
     "description": "Devin Link Text"
   },
-  "faq.section.devin.description": {
-    "message": "是由Cognition Inc.开发的商业产品，它最初为OpenDevin提供了灵感。它们都旨在擅长解决软件工程任务，但您可以下载、使用和修改OpenDevin，而Devin只能通过Cognition网站进行访问。此外，OpenDevin已超越最初的灵感，并成为一个面向代理开发者的社区驱动生态系统，在这里我们欢迎您加入并",
+  "faq.section.openhands.description": {
+    "message": "是由Cognition Inc.开发的商业产品，它最初为OpenHands提供了灵感。它们都旨在擅长解决软件工程任务，但您可以下载、使用和修改OpenHands，而Devin只能通过Cognition网站进行访问。此外，OpenHands已超越最初的灵感，并成为一个面向代理开发者的社区驱动生态系统，在这里我们欢迎您加入并",
     "description": "Devin Description"
   },
-  "faq.section.devin.contribute": {
+  "faq.section.openhands.contribute": {
     "message": "贡献",
     "description": "Contribute Link"
   },
   "faq.section.title.5": {
-    "message": "OpenDevin与ChatGPT有何不同？",
+    "message": "OpenHands与ChatGPT有何不同？",
     "description": "ChatGPT Section Title"
   },
   "faq.section.chatgpt.description": {
@@ -114,7 +114,7 @@
     "message": "开始使用"
   },
   "welcome.message": {
-    "message": "欢迎来到OpenDevin，这是一个开源自主AI软件工程师，能够执行复杂的工程任务，并积极参与用户在软件开发项目中的协作。"
+    "message": "欢迎来到OpenHands，这是一个开源自主AI软件工程师，能够执行复杂的工程任务，并积极参与用户在软件开发项目中的协作。"
   },
   "theme.ErrorPageContent.title": {
     "message": "页面已崩溃。",

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

@@ -19,35 +19,35 @@ sidebar_position: 7
 
 ## 🤝 如何贡献
 
-OpenDevin 是一个社区驱动的项目，我们欢迎每个人的贡献。无论您是开发人员、研究人员，还是对用 AI 提升软件工程领域有兴趣，只要您愿意参与，我们都有很多方式可供选择：
+OpenHands 是一个社区驱动的项目，我们欢迎每个人的贡献。无论您是开发人员、研究人员，还是对用 AI 提升软件工程领域有兴趣，只要您愿意参与，我们都有很多方式可供选择：
 
 - **代码贡献:** 帮助我们开发核心功能、前端界面或沙箱解决方案。
 - **研究和评价:** 贡献您对 LLM 在软件工程领域理解的见解，参与评估模型，或提出改进建议。
-- **反馈和测试:** 使用 OpenDevin 工具集，报告错误，建议功能，或提供可用性方面的反馈。
+- **反馈和测试:** 使用 OpenHands 工具集，报告错误，建议功能，或提供可用性方面的反馈。
 
-详情请查阅[此文件](https://github.com/OpenDevin/OpenDevin/blob/main/CONTRIBUTING.md)。
+详情请查阅[此文件](https://github.com/All-Hands-AI/OpenHands/blob/main/CONTRIBUTING.md)。
 
 ## 🤖 加入我们的社区
 
-我们现在有一个 Slack 工作区，用于合作建设 OpenDevin，还设有一个 Discord 服务器，用于讨论与该项目、LLM、代理等相关的任何事情。
+我们现在有一个 Slack 工作区，用于合作建设 OpenHands，还设有一个 Discord 服务器，用于讨论与该项目、LLM、代理等相关的任何事情。
 
-- [Slack 工作区](https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw)
+- [Slack 工作区](https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA)
 - [Discord 服务器](https://discord.gg/ESHStjSjD4)
 
 如果您愿意贡献，请随时加入我们的社区。让我们一起简化软件工程！
 
-🐚 **少写代码，用 OpenDevin 做更多的事情。**
+🐚 **少写代码，用 OpenHands 做更多的事情。**
 
-[![Star History Chart](https://api.star-history.com/svg?repos=OpenDevin/OpenDevin&type=Date)](https://star-history.com/#OpenDevin/OpenDevin&Date)
+[![Star History Chart](https://api.star-history.com/svg?repos=All-Hands-AI/OpenHands&type=Date)](https://star-history.com/#All-Hands-AI/OpenHands&Date)
 
 ## 🛠️ 技术选型
 
-OpenDevin 使用了一系列强大的框架和库，提供了坚实的开发基础。以下是项目中使用的关键技术：
+OpenHands 使用了一系列强大的框架和库，提供了坚实的开发基础。以下是项目中使用的关键技术：
 
 ![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)
 
-请注意，这些技术选型仍在进行中，随着项目的发展，可能会添加新的技术或移除现有的技术。我们努力采用最适合、最高效的工具，以增强 OpenDevin 的能力。
+请注意，这些技术选型仍在进行中，随着项目的发展，可能会添加新的技术或移除现有的技术。我们努力采用最适合、最高效的工具，以增强 OpenHands 的能力。
 
 ## 📜 许可证
 
-根据 MIT 许可证分发。详见[我们的许可证](https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE)了解更多信息。
+根据 MIT 许可证分发。详见[我们的许可证](https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE)了解更多信息。

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

@@ -18,18 +18,18 @@ sidebar_position: 3
 - 执行任何有效的Linux `bash`命令
 - 使用[交互式Python解释器](https://ipython.org/)执行任何有效的 `Python`代码。这是通过`bash`命令模拟的，详细信息请参见插件系统。
 
-![image](https://github.com/OpenDevin/OpenDevin/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
+![image](https://github.com/All-Hands-AI/OpenHands/assets/38853559/92b622e3-72ad-4a61-8f41-8c040b6d5fb3)
 
 ### 插件系统
 
-为了使CodeAct agent在仅能访问`bash`动作空间时更强大，CodeAct agent利用了OpenDevin的插件系统：
+为了使CodeAct agent在仅能访问`bash`动作空间时更强大，CodeAct agent利用了OpenHands的插件系统：
 
-- [Jupyter插件](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/jupyter)：通过bash命令实现IPython执行
-- [SWE-agent工具插件](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/swe_agent_commands)：为软件开发任务引入的强大bash命令行工具，由[swe-agent](https://github.com/princeton-nlp/swe-agent)提供。
+- [Jupyter插件](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/runtime/plugins/jupyter)：通过bash命令实现IPython执行
+- [SWE-agent工具插件](https://github.com/All-Hands-AI/OpenHands/tree/main/openhands/runtime/plugins/swe_agent_commands)：为软件开发任务引入的强大bash命令行工具，由[swe-agent](https://github.com/princeton-nlp/swe-agent)提供。
 
 ### 演示
 
-https://github.com/OpenDevin/OpenDevin/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
+https://github.com/All-Hands-AI/OpenHands/assets/38853559/f592a192-e86c-4f48-ad31-d69282d5f6ac
 
 _CodeActAgent使用`gpt-4-turbo-2024-04-09`执行数据科学任务（线性回归）的示例_
 

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

@@ -25,13 +25,13 @@ _**免责声明**：后端架构正在进行中，可能会有所变化。下图
 
     ## 前提条件
 
-    - 能运行 python 环境，其中 opendevin 可以执行（根据存储库根目录中的 README.md 文件中的说明）
+    - 能运行 python 环境，其中 openhands 可以执行（根据存储库根目录中的 README.md 文件中的说明）
     - 安装了 [py2puml](https://github.com/lucsorel/py2puml)
 
 ## 步骤
 
 1.  通过从存储库根目录运行以下命令自动生成图表：
-    `py2puml opendevin opendevin > docs/architecture/backend_architecture.puml`
+    `py2puml openhands openhands > docs/architecture/backend_architecture.puml`
 
 2.  在 PlantUML 编辑器中打开生成的文件，例如使用 PlantUML 扩展的 Visual Studio Code 或 [PlantText](https://www.planttext.com/)
 

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

@@ -1,14 +1,31 @@
 # 💿 如何创建自定义 Docker 沙箱
 
-默认的 OpenDevin 沙箱包含一个[最小化 ubuntu 配置](https://github.com/OpenDevin/OpenDevin/blob/main/containers/sandbox/Dockerfile)。您的应用场景可能需要在默认状态下安装额外的软件。本指南将教您如何通过使用自定义 Docker 映像来实现这一目标。
+默认的 OpenHands 沙箱包含一个[最小化 ubuntu 配置](https://github.com/All-Hands-AI/OpenHands/blob/main/containers/sandbox/Dockerfile)。您的应用场景可能需要在默认状态下安装额外的软件。本指南将教您如何通过使用自定义 Docker 映像来实现这一目标。
+
+目前提供两种实现方案：
+1. 从 Docker Hub 拉取已有镜像。例如，如果您想安装 `nodejs` ，您可以通过使用 `node:20` 镜像来实现。
+2. 创建并使用您自定义 Docker 镜像。
+
+若选择第一种方案，您可以直接略过 `Create Your Docker Image` 部分。
+
+为了获得功能更丰富的环境，您可能想要考虑使用预构建的镜像，比如 [nikolaik/python-nodejs](https://hub.docker.com/r/nikolaik/python-nodejs)，这个镜像预装了 Python 和 Node.js，同时还包含了许多其他有用的工具和库，比如：
+
+- Node.js: 22.x
+- npm: 10.x
+- yarn: stable
+- Python: latest
+- pip: latest
+- pipenv: latest
+- poetry: latest
+- uv: latest
 
 ## 环境设置
 
-确保您能够首先通过 [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md) 运行 OpenDevin。
+确保您能够首先通过 [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md) 运行 OpenHands。
 
 ## 创建您的 Docker 映像
 
-接下来，您必须创建一个自定义的 Docker 映像，该映像是基于 Debian 或 Ubuntu 的。例如，如果我们希望 OpenDevin 能够访问 "node" 可执行文件，我们可以使用以下 `Dockerfile`:
+接下来，您可以开始创建一个自定义的 Docker 映像，该映像必须是基于 Debian 或 Ubuntu 的。例如，如果我们希望 OpenHands 能够访问 `node` 可执行文件，我们可以使用以下 `Dockerfile`:
 
 ```bash
 # 从最新版 ubuntu 开始
@@ -21,7 +38,7 @@ RUN apt-get update && apt-get install
 RUN apt-get install -y nodejs
 ```
 
-然后构建您选择的映像，例如“custom_image”。为此可以在目录中创建文件夹并将 `Dockerfile` 放入其中，并在该目录内运行以下命令：
+然后命名并构建您选择的映像，例如“custom_image”。为此可以创建一个文件夹并将 `Dockerfile` 放入其中，并在该文件夹内运行以下命令：
 
 ```bash
 docker build -t custom_image .
@@ -29,77 +46,57 @@ docker build -t custom_image .
 
 这将生成一个名为 ```custom_image``` 的新映像，并使其可用于 Docker 服务引擎。
 
-> 注意：在本文档描述的配置中，OpenDevin 将在沙箱内部以“opendevin”用户身份运行。因此，通过 Dockerfile 安装的所有包应可供系统上的所有用户使用，而不仅仅是 root 用户。
+> 注意：在本文档描述的配置中，OpenHands 将在沙箱内部以“openhands”用户身份运行。因此，通过 Dockerfile 安装的所有包应可供系统上的所有用户使用，而不仅仅是 root 用户。
 
-> 使用 `apt-get` 上面安装的 node 是为所有用户安装的。
+> `Dockerfile`中，使用 `apt-get` 安装的 node 是为所有用户安装的。
 
 ## 在 config.toml 文件中指定自定义映像
 
-在 OpenDevin 的配置通过顶层的 `config.toml` 文件发生。在 OpenDevin 目录下创建一个 ```config.toml``` 文件，并输入以下内容：
+在 OpenHands 的配置通过顶层的 `config.toml` 文件发生。在 OpenHands 目录下创建一个 ```config.toml``` 文件，并输入以下内容：
 
 ```
 [core]
 workspace_base="./workspace"
-run_as_devin=true
-sandbox_container_image="custom_image"
+run_as_openhands=true
+sandbox_base_container_image="custom_image"
 ```
 
-> 确保 `sandbox_container_image` 设置为您前一步中自定义映像的名称。
+对于 `sandbox_base_container_image` 的值, 您可以选择以下任意一项：
+1. 在上一步中您构建的自定义镜像的名称（例如，`“custom_image”`）
+2. 从 Docker Hub 拉取的镜像（例如，`“node:20”`，如果你需要一个预装 `Node.js` 的沙箱环境）
 
 ## 运行
 
-通过运行 ```make run``` 在顶层目录下运行 OpenDevin。
+在顶层目录下通过执行 ```make run``` 运行 OpenHands。
 
 导航至 ```localhost:3001``` 并检查所需依赖是否可用。
 
-在上述示例的情况下，终端中运行 `node -v` 会输出 `v18.19.1`。
+在上述示例的情况下，终端中运行 `node -v` 会输出 `v20.15.0`。
 
 恭喜您！
 
 ## 技术解释
 
-相关代码定义在 [ssh_box.py](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/ssh_box.py) 和 [image_agnostic_util.py](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py) 中。
-
-特别是 ssh_box.py 检查配置对象中的 ```config.sandbox_container_image```，然后尝试使用 [get_od_sandbox_image](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py#L72)，在 image_agnostic_util.py 定义中进行检索。
-
-初次使用自定义映像时，该映像将不会被找到，因此将被构建（在后续运行中已构建的映像将被查找并返回）。
-
-自定义映像是通过 `_build_sandbox_image()` 构建的，在 [image_agnostic_util.py](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py#L29) 中，使用您的 custom_image 作为基础，并为 OpenDevin 配置环境。例如：
-
-```python
-dockerfile_content = (
-        f'FROM {base_image}\n'
-        'RUN apt update && apt install -y openssh-server wget sudo\n'
-        'RUN mkdir -p -m0755 /var/run/sshd\n'
-        'RUN mkdir -p /opendevin && mkdir -p /opendevin/logs && chmod 777 /opendevin/logs\n'
-        'RUN wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"\n'
-        'RUN bash Miniforge3-$(uname)-$(uname -m).sh -b -p /opendevin/miniforge3\n'
-        'RUN bash -c ". /opendevin/miniforge3/etc/profile.d/conda.sh && conda config --set changeps1 False && conda config --append channels conda-forge"\n'
-        'RUN echo "export PATH=/opendevin/miniforge3/bin:$PATH" >> ~/.bashrc\n'
-        'RUN echo "export PATH=/opendevin/miniforge3/bin:$PATH" >> /opendevin/bash.bashrc\n'
-    ).strip()
-```
-
-> 注意：映像名称通过 [_get_new_image_name()](https://github.com/OpenDevin/OpenDevin/blob/main/opendevin/runtime/docker/image_agnostic_util.py#L63) 修改，并且是后续运行中搜索的修改后的名称。
+请参考[运行时文档中自定义 Docker 镜像的章节](https://docs.all-hands.dev/modules/usage/architecture/runtime#advanced-how-openhands-builds-and-maintains-od-runtime-images)获取更详细的解释。
 
 ## 故障排除 / 错误
 
 ### 错误：```useradd: UID 1000 is not unique```
 
-如果在控制台输出中看到此错误，说明 OpenDevin 尝试在沙箱中以 UID 1000 创建 opendevin 用户，但该 UID 已经被映像中的其他部分使用（不知何故）。要解决这个问题，请更改 config.toml 文件中的 sandbox_user_id 字段为不同的值：
+如果在控制台输出中看到此错误，说明 OpenHands 尝试在沙箱中以 UID 1000 创建 openhands 用户，但该 UID 已经被映像中的其他部分使用（不知何故）。要解决这个问题，请更改 config.toml 文件中的 sandbox_user_id 字段为不同的值：
 
 ```
 [core]
 workspace_base="./workspace"
-run_as_devin=true
-sandbox_container_image="custom_image"
+run_as_openhands=true
+sandbox_base_container_image="custom_image"
 sandbox_user_id="1001"
 ```
 
 ### 端口使用错误
 
-如果您看到关于端口被占用或不可用的错误，请尝试删除所有正在运行的 Docker 容器（通过运行 `docker ps` 和 `docker rm` 相关容器），然后重新运行 ```make run```。
+如果您遇到端口被占用或不可用的错误提示，可以尝试先用`docker ps`命令列出所有运行中的 Docker 容器，然后使用`docker rm`命令删除相关容器，最后再重新执行```make run```命令。
 
 ## 讨论
 
-对于其他问题或疑问，请加入 [Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw) 或 [Discord](https://discord.gg/ESHStjSjD4)，并提问！
+对于其他问题或疑问，请加入 [Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA) 或 [Discord](https://discord.gg/ESHStjSjD4) 提问！

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

@@ -4,15 +4,15 @@ sidebar_position: 6
 
 # ✅ 提供反馈
 
-在使用 OpenDevin 时，你无疑会遇到一些情况，某些地方工作得很好，而另一些地方则可能不尽如人意。我们鼓励你在使用 OpenDevin 时提供反馈，这不仅有助于开发团队改善应用，更为重要的是，可以创建一个开放的编码代理训练样例语料库——Share-OpenDevin！
+在使用 OpenHands 时，你无疑会遇到一些情况，某些地方工作得很好，而另一些地方则可能不尽如人意。我们鼓励你在使用 OpenHands 时提供反馈，这不仅有助于开发团队改善应用，更为重要的是，可以创建一个开放的编码代理训练样例语料库——Share-OpenHands！
 
 ## 📝 如何提供反馈
 
-提供反馈很简单！在使用 OpenDevin 时，你可以在任意时刻按下点赞或点踩按钮。你将被要求提供你的电子邮件地址（例如，以便我们在需要进一步询问时联系你），你可以选择公开或私密地提供反馈。
+提供反馈很简单！在使用 OpenHands 时，你可以在任意时刻按下点赞或点踩按钮。你将被要求提供你的电子邮件地址（例如，以便我们在需要进一步询问时联系你），你可以选择公开或私密地提供反馈。
 
 <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>
 
 ## 📜 数据许可与隐私
 
-* **公开** 数据将与 OpenDevin 本身一样以 MIT 许可协议发布，并可被社区用来训练和测试模型。显然，你能够公开的反馈对整个社区来说更有价值，因此当你不涉及敏感信息时，我们鼓励你选择这个选项！
-* **私密** 数据将仅与 OpenDevin 团队分享，用于改进 OpenDevin。
+* **公开** 数据将与 OpenHands 本身一样以 MIT 许可协议发布，并可被社区用来训练和测试模型。显然，你能够公开的反馈对整个社区来说更有价值，因此当你不涉及敏感信息时，我们鼓励你选择这个选项！
+* **私密** 数据将仅与 OpenHands 团队分享，用于改进 OpenHands。

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

@@ -2,47 +2,47 @@
 sidebar_position: 1
 ---
 
-# 💻 OpenDevin
+# 💻 OpenHands
 
-OpenDevin 是一个**自主 AI 软件工程师**，能够执行复杂的工程任务，并在软件开发项目中积极与用户合作。
+OpenHands 是一个**自主 AI 软件工程师**，能够执行复杂的工程任务，并在软件开发项目中积极与用户合作。
 这个项目是完全开源的，所以你可以随意使用和修改它。
 
 :::tip
-在 [GitHub](https://github.com/OpenDevin/OpenDevin) 上探索 OpenDevin 的代码库或加入我们的社区！
+在 [GitHub](https://github.com/All-Hands-AI/OpenHands) 上探索 OpenHands 的代码库或加入我们的社区！
 
-<a href="https://github.com/OpenDevin/OpenDevin/graphs/contributors">
+<a href="https://github.com/All-Hands-AI/OpenHands/graphs/contributors">
   <img
-    src="https://img.shields.io/github/contributors/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/contributors/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Contributors"
   />
 </a>
-<a href="https://github.com/OpenDevin/OpenDevin/network/members">
+<a href="https://github.com/All-Hands-AI/OpenHands/network/members">
   <img
-    src="https://img.shields.io/github/forks/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/forks/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Forks"
   />
 </a>
-<a href="https://github.com/OpenDevin/OpenDevin/stargazers">
+<a href="https://github.com/All-Hands-AI/OpenHands/stargazers">
   <img
-    src="https://img.shields.io/github/stars/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/stars/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Stargazers"
   />
 </a>
-<a href="https://github.com/OpenDevin/OpenDevin/issues">
+<a href="https://github.com/All-Hands-AI/OpenHands/issues">
   <img
-    src="https://img.shields.io/github/issues/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/issues/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="Issues"
   />
 </a>
 <br></br>
-<a href="https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE">
+<a href="https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE">
   <img
-    src="https://img.shields.io/github/license/opendevin/opendevin?style=for-the-badge"
+    src="https://img.shields.io/github/license/All-Hands-AI/OpenHands?style=for-the-badge"
     alt="MIT License"
   />
 </a>
 <br></br>
-<a href="https://join.slack.com/t/opendevin/shared_invite/zt-2ngejmfw6-9gW4APWOC9XUp1n~SiQ6iw">
+<a href="https://join.slack.com/t/opendevin/shared_invite/zt-2oikve2hu-UDxHeo8nsE69y6T7yFX_BA">
   <img
     src="https://img.shields.io/badge/Slack-Join%20Us-red?logo=slack&logoColor=white&style=for-the-badge"
     alt="Join our Slack community"
@@ -58,10 +58,10 @@ OpenDevin 是一个**自主 AI 软件工程师**，能够执行复杂的工程
 
 ## 🛠️ 入门指南
 
-运行 OpenDevin 最简单的方法是在 Docker 容器中。它在 Docker 的最新版本 `26.0.0` 上运行效果最佳。
+运行 OpenHands 最简单的方法是在 Docker 容器中。它在 Docker 的最新版本 `26.0.0` 上运行效果最佳。
 你必须使用 Linux、Mac OS 或 Windows 上的 WSL。
 
-要在 Docker 容器中启动 OpenDevin，请在终端中运行以下命令：
+要在 Docker 容器中启动 OpenHands，请在终端中运行以下命令：
 
 :::warning
 运行以下命令时，`./workspace` 中的文件可能会被修改或删除。
@@ -77,33 +77,33 @@ docker run -it \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -p 3000:3000 \
     --add-host host.docker.internal:host-gateway \
-    --name opendevin-app-$(date +%Y%m%d%H%M%S) \
-    ghcr.io/opendevin/opendevin:0.6
+    --name openhands-app-$(date +%Y%m%d%H%M%S) \
+    ghcr.io/all-hands-ai/openhands:main
 ```
 
-你会发现 OpenDevin 在 [http://localhost:3000](http://localhost:3000) 运行，并可以访问 `./workspace`。要让 OpenDevin 操作你的代码，请将代码放在 `./workspace` 中。
+你会发现 OpenHands 在 [http://localhost:3000](http://localhost:3000) 运行，并可以访问 `./workspace`。要让 OpenHands 操作你的代码，请将代码放在 `./workspace` 中。
 
-OpenDevin 只会访问这个工作区文件夹。它在一个安全的 docker 沙盒中运行，不会影响你系统的其他部分。
+OpenHands 只会访问这个工作区文件夹。它在一个安全的 docker 沙盒中运行，不会影响你系统的其他部分。
 
 :::tip
-如果你想使用**（不稳定！）**最新版本，可以使用 `ghcr.io/opendevin/opendevin:main` 作为镜像（最后一行）。
+如果你想使用**（不稳定！）**最新版本，可以使用 `ghcr.io/all-hands-ai/openhands:main` 作为镜像（最后一行）。
 :::
 
-有关开发工作流程，请参阅 [Development.md](https://github.com/OpenDevin/OpenDevin/blob/main/Development.md)。
+有关开发工作流程，请参阅 [Development.md](https://github.com/All-Hands-AI/OpenHands/blob/main/Development.md)。
 
 遇到问题了吗？查看我们的 [故障排除指南](https://docs.all-hands.dev/modules/usage/troubleshooting)。
 
 :::warning
-OpenDevin 目前正在开发中，但你已经可以运行 alpha 版本来查看端到端系统的运作情况。
+OpenHands 目前正在开发中，但你已经可以运行 alpha 版本来查看端到端系统的运作情况。
 :::
 
-[contributors-shield]: https://img.shields.io/github/contributors/opendevin/opendevin?style=for-the-badge
-[contributors-url]: https://github.com/OpenDevin/OpenDevin/graphs/contributors
-[forks-shield]: https://img.shields.io/github/forks/opendevin/opendevin?style=for-the-badge
-[forks-url]: https://github.com/OpenDevin/OpenDevin/network/members
-[stars-shield]: https://img.shields.io/github/stars/opendevin/opendevin?style=for-the-badge
-[stars-url]: https://github.com/OpenDevin/OpenDevin/stargazers
-[issues-shield]: https://img.shields.io/github/issues/opendevin/opendevin?style=for-the-badge
-[issues-url]: https://github.com/OpenDevin/OpenDevin/issues
-[license-shield]: https://img.shields.io/github/license/opendevin/opendevin?style=for-the-badge
-[license-url]: https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE
+[contributors-shield]: https://img.shields.io/github/contributors/All-Hands-AI/OpenHands?style=for-the-badge
+[contributors-url]: https://github.com/All-Hands-AI/OpenHands/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/All-Hands-AI/OpenHands?style=for-the-badge
+[forks-url]: https://github.com/All-Hands-AI/OpenHands/network/members
+[stars-shield]: https://img.shields.io/github/stars/All-Hands-AI/OpenHands?style=for-the-badge
+[stars-url]: https://github.com/All-Hands-AI/OpenHands/stargazers
+[issues-shield]: https://img.shields.io/github/issues/All-Hands-AI/OpenHands?style=for-the-badge
+[issues-url]: https://github.com/All-Hands-AI/OpenHands/issues
+[license-shield]: https://img.shields.io/github/license/All-Hands-AI/OpenHands?style=for-the-badge
+[license-url]: https://github.com/All-Hands-AI/OpenHands/blob/main/LICENSE

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

@@ -2,11 +2,11 @@
 
 ## 完成
 
-OpenDevin 使用 LiteLLM 进行完成调用。你可以在 Azure 的文档中找到他们的文档 [这里](https://docs.litellm.ai/docs/providers/azure)
+OpenHands 使用 LiteLLM 进行完成调用。你可以在 Azure 的文档中找到他们的文档 [这里](https://docs.litellm.ai/docs/providers/azure)
 
 ### Azure openai 配置
 
-在运行 OpenDevin Docker 镜像时，你需要使用 `-e` 设置以下环境变量：
+在运行 OpenHands Docker 镜像时，你需要使用 `-e` 设置以下环境变量：
 
 ```
 LLM_BASE_URL="<azure-api-base-url>"          # 示例: "https://openai-gpt-4-test-v-1.openai.azure.com/"
@@ -16,19 +16,19 @@ LLM_API_VERSION = "<api-version>"          # 示例: "2024-02-15-preview"
 ```
 
 :::note
-你可以在 Azure 的部署页面找到你的 ChatGPT 部署名称。它可能与默认或最初设置的聊天模型名称相同（例如 'GPT4-1106-preview'），但不一定相同。运行 OpenDevin，当你在浏览器中加载它时，进入设置并按照上述方式设置模型: "azure/&lt;your-actual-gpt-deployment-name&gt;"。如果列表中没有，请输入你自己的文本并保存。
+你可以在 Azure 的部署页面找到你的 ChatGPT 部署名称。它可能与默认或最初设置的聊天模型名称相同（例如 'GPT4-1106-preview'），但不一定相同。运行 OpenHands，当你在浏览器中加载它时，进入设置并按照上述方式设置模型: "azure/&lt;your-actual-gpt-deployment-name&gt;"。如果列表中没有，请输入你自己的文本并保存。
 :::
 
 ## 嵌入
 
-OpenDevin 使用 llama-index 进行嵌入。你可以在 Azure 的文档中找到他们的文档 [这里](https://docs.llamaindex.ai/en/stable/api_reference/embeddings/azure_openai/)
+OpenHands 使用 llama-index 进行嵌入。你可以在 Azure 的文档中找到他们的文档 [这里](https://docs.llamaindex.ai/en/stable/api_reference/embeddings/azure_openai/)
 
 ### Azure openai 配置
 
 Azure OpenAI 嵌入使用的模型是 "text-embedding-ada-002"。
 你需要在你的 Azure 账户中为这个模型设置正确的部署名称。
 
-在 Docker 中运行 OpenDevin 时，使用 `-e` 设置以下环境变量：
+在 Docker 中运行 OpenHands 时，使用 `-e` 设置以下环境变量：
 
 ```
 LLM_EMBEDDING_MODEL="azureopenai"

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

@@ -2,14 +2,14 @@
 
 ## Completion
 
-OpenDevin 使用 LiteLLM 进行补全调用。以下资源与使用 OpenDevin 和 Google 的 LLM 相关：
+OpenHands 使用 LiteLLM 进行补全调用。以下资源与使用 OpenHands 和 Google 的 LLM 相关：
 
 - [Gemini - Google AI Studio](https://docs.litellm.ai/docs/providers/gemini)
 - [VertexAI - Google Cloud Platform](https://docs.litellm.ai/docs/providers/vertex)
 
 ### Gemini - Google AI Studio 配置
 
-在运行 OpenDevin Docker 镜像时，通过 Google AI Studio 使用 Gemini，你需要使用 `-e` 设置以下环境变量：
+在运行 OpenHands Docker 镜像时，通过 Google AI Studio 使用 Gemini，你需要使用 `-e` 设置以下环境变量：
 
 ```
 GEMINI_API_KEY="<your-google-api-key>"
@@ -18,7 +18,7 @@ LLM_MODEL="gemini/gemini-1.5-pro"
 
 ### Vertex AI - Google Cloud Platform 配置
 
-在运行 OpenDevin Docker 镜像时，通过 Google Cloud Platform 使用 Vertex AI，你需要使用 `-e` 设置以下环境变量：
+在运行 OpenHands Docker 镜像时，通过 Google Cloud Platform 使用 Vertex AI，你需要使用 `-e` 设置以下环境变量：
 
 ```
 GOOGLE_APPLICATION_CREDENTIALS="<json-dump-of-gcp-service-account-json>"

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

@@ -4,16 +4,16 @@ sidebar_position: 2
 
 # 🤖 LLM 支持
 
-OpenDevin 可以兼容任何 LLM 后端。
+OpenHands 可以兼容任何 LLM 后端。
 关于所有可用 LM 提供商和模型的完整列表，请参阅
 [litellm 文档](https://docs.litellm.ai/docs/providers)。
 
 :::warning
-OpenDevin 将向你配置的 LLM 发出许多提示。大多数这些 LLM 都是收费的——请务必设定支出限额并监控使用情况。
+OpenHands 将向你配置的 LLM 发出许多提示。大多数这些 LLM 都是收费的——请务必设定支出限额并监控使用情况。
 :::
 
 `LLM_MODEL` 环境变量控制在编程交互中使用的模型。
-但在使用 OpenDevin UI 时，你需要在设置窗口中选择你的模型（左下角的齿轮）。
+但在使用 OpenHands UI 时，你需要在设置窗口中选择你的模型（左下角的齿轮）。
 
 某些 LLM 可能需要以下环境变量：
 
@@ -23,10 +23,10 @@ OpenDevin 将向你配置的 LLM 发出许多提示。大多数这些 LLM 都是
 - `LLM_EMBEDDING_DEPLOYMENT_NAME`
 - `LLM_API_VERSION`
 
-我们有一些指南，介绍了如何使用特定模型提供商运行 OpenDevin：
+我们有一些指南，介绍了如何使用特定模型提供商运行 OpenHands：
 
-- [ollama](llms/localLLMs)
-- [Azure](llms/azureLLMs)
+- [ollama](llms/local-llms)
+- [Azure](llms/azure-llms)
 
 如果你使用其他提供商，我们鼓励你打开一个 PR 来分享你的配置！
 
@@ -35,12 +35,12 @@ OpenDevin 将向你配置的 LLM 发出许多提示。大多数这些 LLM 都是
 最好的模型是 GPT-4 和 Claude 3。目前的本地和开源模型
 远没有那么强大。当使用替代模型时，
 你可能会看到信息之间的长时间等待，
-糟糕的响应，或关于 JSON格式错误的错误。OpenDevin
+糟糕的响应，或关于 JSON格式错误的错误。OpenHands
 的强大程度依赖于其驱动的模型——幸运的是，我们团队的人员
 正在积极致力于构建更好的开源模型！
 
 ## API 重试和速率限制
 
-一些 LLM 有速率限制，可能需要重试操作。OpenDevin 会在收到 429 错误或 API 连接错误时自动重试请求。
+一些 LLM 有速率限制，可能需要重试操作。OpenHands 会在收到 429 错误或 API 连接错误时自动重试请求。
 你可以设置 `LLM_NUM_RETRIES`，`LLM_RETRY_MIN_WAIT`，`LLM_RETRY_MAX_WAIT` 环境变量来控制重试次数和重试之间的时间。
-默认情况下，`LLM_NUM_RETRIES` 为 5，`LLM_RETRY_MIN_WAIT` 和 `LLM_RETRY_MAX_WAIT` 分别为 3 秒和 60 秒。
+默认情况下，`LLM_NUM_RETRIES` 为 8，`LLM_RETRY_MIN_WAIT` 和 `LLM_RETRY_MAX_WAIT` 分别为 15 秒和 120 秒。