docs: add pt-BR translation for official docs (#7416)

Development.md

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

docs/README.md

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

docs/docusaurus.config.ts

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

docs/i18n/pt-BR/code.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

docs/translation_cache.json

@@ -1 +1,32 @@
-{"docs/modules/python/python.md": "da5d692f477f4a213d77474f02850026", "docs/modules/usage/getting-started.mdx": "a01bc308197184468acf45e105e80651", "docs/modules/usage/agents.md": "9227679a22d810d6aab574a295bd273e", "docs/modules/usage/about.md": "5e7509aadb213a1c1a48e0de1858e55f", "docs/modules/usage/feedback.md": "c2d135cb1368f39a4d34d7ad0e3eeafd", "docs/modules/usage/runtimes.md": "4b5927f2654b328e1f94ab9098ab4441", "docs/modules/usage/installation.mdx": "a552e56d6af1af0893568a1bd396f692", "docs/modules/usage/configuration-options.md": "9907ec2c99dd084cb4e8acb03d6000e5", "docs/modules/usage/prompting/microagents.md": "fb278bcb98f6e049e7deb512b1288ebf", "docs/modules/usage/prompting/customization.md": "935b2cbeef113e043219c312b77803ed", "docs/modules/usage/prompting/prompting-best-practices.md": "2dc7a8130973e246d559e4222ad5f2e7", "docs/modules/usage/troubleshooting/troubleshooting.md": "a882fb995a404d1b4988a5d878d9285f", "docs/modules/usage/how-to/gui-mode.md": "54afe83d5d8e13395add7bf64205d589", "docs/modules/usage/how-to/evaluation-harness.md": "c28a79ecac02933c463197e33c3034e3", "docs/modules/usage/how-to/github-action.md": "a2ba43f6592453925038b1a14038a882", "docs/modules/usage/how-to/headless-mode.md": "27d251e230f2027d64d2be9cfc7e3301", "docs/modules/usage/how-to/custom-sandbox-guide.md": "f8478796084b118e990182204610e1b4", "docs/modules/usage/how-to/debugging.md": "d846a3eb9384ab24f3e1b3e8161b5f1a", "docs/modules/usage/how-to/persist-session-data.md": "5733d67f15ed2eb4212c0e7457d4c253", "docs/modules/usage/how-to/cli-mode.md": "476d62f7c38ae74da8e519769132d077", "docs/modules/usage/architecture/backend.mdx": "3aa3d71833438063a344453e64e7029b", "docs/modules/usage/architecture/runtime.md": "83b213c35bd3b0d284dd236ce0a7c2d2", "docs/modules/usage/llms/llms.md": "5db0a92e832c57ca6e2b70459df40096", "docs/modules/usage/llms/local-llms.md": "63b6966e52ab9f3f6818f0c1108d5061", "docs/modules/usage/llms/groq.md": "b0c6c5fc0955afa46628b1cf3bb8a363", "docs/modules/usage/llms/google-llms.md": "0ff0f62503db41f2a3329db218c86b3f", "docs/modules/usage/llms/openai-llms.md": "46c05cd1f12db498d352e23d7b06beba", "docs/modules/usage/llms/azure-llms.md": "af4b524a90a0c29e1e0981a1a4234fe8", "docs/modules/usage/llms/litellm-proxy.md": "0a3a5f75488d78bfaf9ad299e66c8af3", "docs/modules/usage/llms/openrouter.md": "5027074af745c63491edf7fe3f5a242d"}
+{
+    "docs/modules/python/python.md": "da5d692f477f4a213d77474f02850026",
+    "docs/modules/usage/getting-started.mdx": "a01bc308197184468acf45e105e80651",
+    "docs/modules/usage/agents.md": "9227679a22d810d6aab574a295bd273e",
+    "docs/modules/usage/about.md": "5e7509aadb213a1c1a48e0de1858e55f",
+    "docs/modules/usage/feedback.md": "c2d135cb1368f39a4d34d7ad0e3eeafd",
+    "docs/modules/usage/runtimes.md": "4b5927f2654b328e1f94ab9098ab4441",
+    "docs/modules/usage/installation.mdx": "a552e56d6af1af0893568a1bd396f692",
+    "docs/modules/usage/configuration-options.md": "9907ec2c99dd084cb4e8acb03d6000e5",
+    "docs/modules/usage/prompting/microagents.md": "fb278bcb98f6e049e7deb512b1288ebf",
+    "docs/modules/usage/prompting/customization.md": "935b2cbeef113e043219c312b77803ed",
+    "docs/modules/usage/prompting/prompting-best-practices.md": "2dc7a8130973e246d559e4222ad5f2e7",
+    "docs/modules/usage/troubleshooting/troubleshooting.md": "a882fb995a404d1b4988a5d878d9285f",
+    "docs/modules/usage/how-to/gui-mode.md": "54afe83d5d8e13395add7bf64205d589",
+    "docs/modules/usage/how-to/evaluation-harness.md": "c28a79ecac02933c463197e33c3034e3",
+    "docs/modules/usage/how-to/github-action.md": "a2ba43f6592453925038b1a14038a882",
+    "docs/modules/usage/how-to/headless-mode.md": "27d251e230f2027d64d2be9cfc7e3301",
+    "docs/modules/usage/how-to/custom-sandbox-guide.md": "f8478796084b118e990182204610e1b4",
+    "docs/modules/usage/how-to/debugging.md": "d846a3eb9384ab24f3e1b3e8161b5f1a",
+    "docs/modules/usage/how-to/persist-session-data.md": "5733d67f15ed2eb4212c0e7457d4c253",
+    "docs/modules/usage/how-to/cli-mode.md": "476d62f7c38ae74da8e519769132d077",
+    "docs/modules/usage/architecture/backend.mdx": "3aa3d71833438063a344453e64e7029b",
+    "docs/modules/usage/architecture/runtime.md": "83b213c35bd3b0d284dd236ce0a7c2d2",
+    "docs/modules/usage/llms/llms.md": "5db0a92e832c57ca6e2b70459df40096",
+    "docs/modules/usage/llms/local-llms.md": "63b6966e52ab9f3f6818f0c1108d5061",
+    "docs/modules/usage/llms/groq.md": "b0c6c5fc0955afa46628b1cf3bb8a363",
+    "docs/modules/usage/llms/google-llms.md": "0ff0f62503db41f2a3329db218c86b3f",
+    "docs/modules/usage/llms/openai-llms.md": "46c05cd1f12db498d352e23d7b06beba",
+    "docs/modules/usage/llms/azure-llms.md": "af4b524a90a0c29e1e0981a1a4234fe8",
+    "docs/modules/usage/llms/litellm-proxy.md": "0a3a5f75488d78bfaf9ad299e66c8af3",
+    "docs/modules/usage/llms/openrouter.md": "5027074af745c63491edf7fe3f5a242d"
+}

docs/translation_updater.py

@@ -18,7 +18,11 @@ DOCS_DIR = 'docs/'
 CACHE_FILE = os.path.join(DOCS_DIR, 'translation_cache.json')
 
 # Supported languages and their codes
-LANGUAGES = {'fr': 'French', 'zh-Hans': 'Simplified Chinese'}
+LANGUAGES = {
+    'fr': 'French',
+    'zh-Hans': 'Simplified Chinese',
+    'pt-BR': 'Brazilian Portuguese',
+}
 
 
 def get_file_hash(filepath):

frontend/README.md

@@ -48,6 +48,8 @@ This will start the application in development mode. Open [http://localhost:3001
 
 **NOTE: The backend is _partially_ mocked using `msw`. Therefore, some features may not work as they would with the actual backend.**
 
+See the [Development.md](../Development.md) for extra tips on how to run in development mode.
+
 ### Running the Application with the Actual Backend (Production Mode)
 
 To run the application with the actual backend: