@neurocode-ai/web 1.18.8

package/src/content/docs/es/models.mdx

@@ -0,0 +1,223 @@
+---
+title: Modelos
+description: Configuración de un proveedor y modelo LLM.
+---
+
+OpenCode usa el [AI SDK](https://ai-sdk.dev/) y [Models.dev](https://models.dev) para admitir **75+ proveedores LLM** y admite la ejecución de modelos locales.
+
+---
+
+## Proveedores
+
+Los proveedores más populares están precargados de forma predeterminada. Si agregó las credenciales de un proveedor mediante el comando `/connect`, estarán disponibles cuando inicie OpenCode.
+
+Obtenga más información sobre [proveedores](/docs/providers).
+
+---
+
+## Seleccionar un modelo
+
+Una vez que hayas configurado tu proveedor podrás seleccionar el modelo que desees escribiendo:
+
+```bash frame="none"
+/models
+```
+
+---
+
+## Modelos recomendados
+
+Hay muchos modelos disponibles y cada semana salen nuevos modelos.
+
+:::tip
+Considere utilizar uno de los modelos que recomendamos.
+:::
+
+Sin embargo, sólo unos pocos de ellos son buenos tanto para generar código como para llamar a herramientas.
+
+Aqui tienes varios modelos que funcionan bien con OpenCode, sin orden particular. (Esta no es una lista exhaustiva ni necesariamente actualizada):
+
+- GPT 5.2
+- GPT 5.1 Codex
+- Claude Opus 4.5
+- Claude Sonnet 4.5
+- Minimax M2.1
+- Gemini 3 Pro
+
+---
+
+## Establecer un valor predeterminado
+
+Para configurar uno de estos como modelo predeterminado, puedes definir la clave `model` en tu
+configuracion de OpenCode.
+
+```json title="opencode.json" {3}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "lmstudio/google/gemma-3n-e4b"
+}
+```
+
+Aquí el ID completo es `provider_id/model_id`. Por ejemplo, si usa [OpenCode Zen](/docs/zen), usaría `opencode/gpt-5.1-codex` para GPT 5.1 Codex.
+
+Si ha configurado un [proveedor personalizado](/docs/providers#custom), `provider_id` es la clave de la parte `provider` de su configuración y `model_id` es la clave de `provider.models`.
+
+---
+
+## Configurar modelos
+
+Puede configurar globalmente las opciones de un modelo a través de la configuración.
+
+```jsonc title="opencode.jsonc" {7-12,19-24}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openai": {
+      "models": {
+        "gpt-5": {
+          "options": {
+            "reasoningEffort": "high",
+            "textVerbosity": "low",
+            "reasoningSummary": "auto",
+            "include": ["reasoning.encrypted_content"],
+          },
+        },
+      },
+    },
+    "anthropic": {
+      "models": {
+        "claude-sonnet-4-5-20250929": {
+          "options": {
+            "thinking": {
+              "type": "enabled",
+              "budgetTokens": 16000,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Aquí estamos configurando ajustes globales para dos modelos integrados: `gpt-5` cuando se accede a través del proveedor `openai` y `claude-sonnet-4-20250514` cuando se accede a través del proveedor `anthropic`.
+Los nombres de modelo y proveedor integrados se pueden encontrar en [Models.dev](https://models.dev).
+
+También puede configurar estas opciones para cualquier agente que esté utilizando. La configuración del agente anula cualquier opción global aquí. [Más información](/docs/agents/#additional).
+
+También puede definir variantes personalizadas que amplíen las integradas. Las variantes le permiten configurar diferentes ajustes para el mismo modelo sin crear entradas duplicadas:
+
+```jsonc title="opencode.jsonc" {6-21}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "opencode": {
+      "models": {
+        "gpt-5": {
+          "variants": {
+            "high": {
+              "reasoningEffort": "high",
+              "textVerbosity": "low",
+              "reasoningSummary": "auto",
+            },
+            "low": {
+              "reasoningEffort": "low",
+              "textVerbosity": "low",
+              "reasoningSummary": "auto",
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+---
+
+## Variantes
+
+Muchos modelos admiten múltiples variantes con diferentes configuraciones. OpenCode se envía con variantes predeterminadas integradas para proveedores populares.
+
+### Variantes integradas
+
+OpenCode se envía con variantes predeterminadas para muchos proveedores:
+
+**Anthropic**:
+
+- `high` - Presupuesto de pensamiento alto (predeterminado)
+- `max` - Presupuesto de pensamiento máximo
+
+**OpenAI**:
+
+Varía según el modelo, pero aproximadamente:
+
+- `none` - Sin razonamiento
+- `minimal` - Mínimo esfuerzo de razonamiento
+- `low` - Bajo esfuerzo de razonamiento
+- `medium` - Esfuerzo de razonamiento medio
+- `high` - Alto esfuerzo de razonamiento
+- `xhigh` - Esfuerzo de razonamiento extra alto
+
+**Google**:
+
+- `low` - Menor esfuerzo/presupuesto simbólico
+- `high` - Mayor esfuerzo/presupuesto simbólico
+
+:::tip
+Esta lista no es exhaustiva. Muchos otros proveedores también tienen valores predeterminados integrados.
+:::
+
+### Variantes personalizadas
+
+Puede anular las variantes existentes o agregar las suyas propias:
+
+```jsonc title="opencode.jsonc" {7-18}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openai": {
+      "models": {
+        "gpt-5": {
+          "variants": {
+            "thinking": {
+              "reasoningEffort": "high",
+              "textVerbosity": "low",
+            },
+            "fast": {
+              "disabled": true,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+### Alternar variantes
+
+Utilice la combinación de teclas `variant_cycle` para cambiar rápidamente entre variantes. [Más información](/docs/keybinds).
+
+---
+
+## Carga de modelos
+
+Cuando se inicia OpenCode, busca modelos en el siguiente orden de prioridad:
+
+1. El indicador de línea de comando `--model` o `-m`. El formato es el mismo que en el archivo de configuración: `provider_id/model_id`.
+
+2. La lista de modelos en la configuración OpenCode.
+
+   ```json title="opencode.json"
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "model": "anthropic/claude-sonnet-4-20250514"
+   }
+   ```
+
+   El formato aquí es `provider/model`.
+
+3. El último modelo utilizado.
+
+4. El primer modelo que utiliza una prioridad interna.

package/src/content/docs/es/network.mdx

@@ -0,0 +1,57 @@
+---
+title: Red
+description: Configure proxies y certificados personalizados.
+---
+
+OpenCode admite variables de entorno de proxy estándar y certificados personalizados para entornos de red empresarial.
+
+---
+
+## Proxy
+
+OpenCode respeta las variables de entorno de proxy estándar.
+
+```bash
+# HTTPS proxy (recommended)
+export HTTPS_PROXY=https://proxy.example.com:8080
+
+# HTTP proxy (if HTTPS not available)
+export HTTP_PROXY=http://proxy.example.com:8080
+
+# Bypass proxy for local server (required)
+export NO_PROXY=localhost,127.0.0.1
+```
+
+:::caution
+El TUI se comunica con un servidor HTTP local. Debe omitir el proxy para esta conexión para evitar bucles de enrutamiento.
+:::
+
+Puede configurar el puerto y el nombre de host del servidor usando [CLI flags](/docs/cli#run).
+
+---
+
+### Autenticación
+
+Si su proxy requiere autenticación básica, incluya las credenciales en la URL.
+
+```bash
+export HTTPS_PROXY=http://username:password@proxy.example.com:8080
+```
+
+:::caution
+Evite codificar contraseñas. Utilice variables de entorno o almacenamiento seguro de credenciales.
+:::
+
+Para servidores proxy que requieren autenticación avanzada como NTLM o Kerberos, considere usar una puerta de enlace LLM que admita su método de autenticación.
+
+---
+
+## Certificados personalizados
+
+Si su empresa utiliza CA personalizadas para conexiones HTTPS, configure OpenCode para confiar en ellas.
+
+```bash
+export NODE_EXTRA_CA_CERTS=/path/to/ca-cert.pem
+```
+
+Esto funciona tanto para conexiones proxy como para acceso directo a API.

package/src/content/docs/es/permissions.mdx

@@ -0,0 +1,235 @@
+---
+title: Permisos
+description: Controle qué acciones requieren aprobación para ejecutarse.
+---
+
+OpenCode usa la configuración `permission` para decidir si una acción determinada debe ejecutarse automáticamente, avisarle o bloquearse.
+
+A partir de `v1.1.1`, la configuración booleana heredada `tools` está obsoleta y se ha fusionado en `permission`. La antigua configuración `tools` todavía se admite por compatibilidad con versiones anteriores.
+
+---
+
+## Acciones
+
+Cada regla de permiso se resuelve en una de:
+
+- `"allow"` — ejecutar sin aprobación
+- `"ask"` — solicitar aprobación
+- `"deny"` — bloquea la acción
+
+---
+
+## Configuración
+
+Puede establecer permisos globalmente (con `*`) y anular herramientas específicas.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "*": "ask",
+    "bash": "allow",
+    "edit": "deny"
+  }
+}
+```
+
+También puedes configurar todos los permisos a la vez:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": "allow"
+}
+```
+
+---
+
+## Reglas granulares (sintaxis de objeto)
+
+Para la mayoría de los permisos, puede utilizar un objeto para aplicar diferentes acciones según la entrada de la herramienta.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": {
+      "*": "ask",
+      "git *": "allow",
+      "npm *": "allow",
+      "rm *": "deny",
+      "grep *": "allow"
+    },
+    "edit": {
+      "*": "deny",
+      "packages/web/src/content/docs/*.mdx": "allow"
+    }
+  }
+}
+```
+
+Las reglas se evalúan según la coincidencia de patrones, y la **última regla coincidente gana**. Un patrón común es poner primero la regla general `"*"` y después reglas más específicas.
+
+### Comodines
+
+Los patrones de permisos utilizan una simple coincidencia de comodines:
+
+- `*` coincide con cero o más de cualquier carácter
+- `?` coincide exactamente con un carácter
+- Todos los demás caracteres coinciden literalmente
+
+### Expansión del directorio de inicio
+
+Puede usar `~` o `$HOME` al comienzo de un patrón para hacer referencia a su directorio de inicio. Esto es particularmente útil para las reglas [`external_directory`](#external-directories).
+
+- `~/projects/*` -> `/Users/username/projects/*`
+- `$HOME/projects/*` -> `/Users/username/projects/*`
+- `~` -> `/Users/username`
+
+### Directorios externos
+
+Utilice `external_directory` para permitir llamadas a herramientas que toquen rutas fuera del directorio de trabajo donde se inició OpenCode. Esto se aplica a cualquier herramienta que tome una ruta como entrada (por ejemplo, `read`, `edit`, `glob`, `grep` y muchos comandos `bash`).
+
+La expansión del hogar (como `~/...`) solo afecta la forma en que se escribe un patrón. No hace que una ruta externa forme parte del espacio de trabajo actual, por lo que las rutas fuera del directorio de trabajo aún deben permitirse a través de `external_directory`.
+
+Por ejemplo, esto permite el acceso a todo lo que se encuentra en `~/projects/personal/`:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    }
+  }
+}
+```
+
+Cualquier directorio permitido aquí hereda los mismos valores predeterminados que el espacio de trabajo actual. Dado que [`read` tiene por defecto `allow`](#defaults), también se permiten lecturas para entradas bajo `external_directory` a menos que se anulen. Agregue reglas explícitas cuando una herramienta deba restringirse en estas rutas, como bloquear ediciones mientras se mantienen las lecturas:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    },
+    "edit": {
+      "~/projects/personal/**": "deny"
+    }
+  }
+}
+```
+
+Mantenga la lista centrada en rutas confiables y aplique reglas adicionales de permitir o denegar según sea necesario para otras herramientas (por ejemplo, `bash`).
+
+---
+
+## Permisos disponibles
+
+Los permisos OpenCode están codificados por el nombre de la herramienta, además de un par de medidas de seguridad:
+
+- `read` — leer un archivo (coincide con la ruta del archivo)
+- `edit` — todas las modificaciones de archivos (cubre `edit`, `write`, `patch`)
+- `glob` — globalización de archivos (coincide con el patrón global)
+- `grep` — búsqueda de contenido (coincide con el patrón de expresiones regulares)
+- `bash`: ejecuta comandos de shell (coincide con comandos analizados como `git status --porcelain`)
+- `task` — lanzamiento de subagentes (coincide con el tipo de subagente)
+- `skill` — cargar una habilidad (coincide con el nombre de la habilidad)
+- `lsp`: ejecución de consultas LSP (actualmente no granulares)
+- `webfetch` — obteniendo una URL (coincide con la URL)
+- `websearch` — búsqueda web (coincide con la consulta)
+- `external_directory`: se activa cuando una herramienta toca rutas fuera del directorio de trabajo del proyecto.
+- `doom_loop`: se activa cuando la misma llamada de herramienta se repite 3 veces con entrada idéntica
+
+---
+
+## Valores predeterminados
+
+Si no especifica nada, OpenCode comienza desde valores predeterminados permisivos:
+
+- La mayoría de los permisos están predeterminados en `"allow"`.
+- `doom_loop` y `external_directory` por defecto son `"ask"`.
+- `read` es `"allow"`, pero los archivos `.env` están denegados de forma predeterminada:
+
+```json title="opencode.json"
+{
+  "permission": {
+    "read": {
+      "*": "allow",
+      "*.env": "deny",
+      "*.env.*": "deny",
+      "*.env.example": "allow"
+    }
+  }
+}
+```
+
+---
+
+## ¿Qué significa "preguntar"?
+
+Cuando OpenCode solicita aprobación, la interfaz de usuario ofrece tres resultados:
+
+- `once` — aprobar solo esta solicitud
+- `always`: aprueba solicitudes futuras que coincidan con los patrones sugeridos (para el resto de la sesión actual OpenCode)
+- `reject` — rechazar la solicitud
+
+La herramienta proporciona el conjunto de patrones que `always` aprobaría (por ejemplo, las aprobaciones de bash generalmente incluyen en la lista blanca un prefijo de comando seguro como `git status*`).
+
+---
+
+## Agentes
+
+Puede anular los permisos por agente. Los permisos del agente se combinan con la configuración global y las reglas del agente tienen prioridad. [Más información](/docs/agents#permissions) sobre los permisos de los agentes.
+
+:::note
+Consulte la sección [Reglas granulares (sintaxis de objeto)](#granular-rules-object-syntax) anterior para obtener ejemplos de coincidencia de patrones más detallados.
+:::
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": {
+      "*": "ask",
+      "git *": "allow",
+      "git commit *": "deny",
+      "git push *": "deny",
+      "grep *": "allow"
+    }
+  },
+  "agent": {
+    "build": {
+      "permission": {
+        "bash": {
+          "*": "ask",
+          "git *": "allow",
+          "git commit *": "ask",
+          "git push *": "deny",
+          "grep *": "allow"
+        }
+      }
+    }
+  }
+}
+```
+
+También puede configurar los permisos del agente en Markdown:
+
+```markdown title="~/.config/opencode/agents/review.md"
+---
+description: Code review without edits
+mode: subagent
+permission:
+  edit: deny
+  bash: ask
+  webfetch: deny
+---
+
+Only analyze code and suggest changes.
+```
+
+:::tip
+Utilice la coincidencia de patrones para comandos con argumentos. `"grep *"` permite `grep pattern file.txt`, mientras que `"grep"` solo lo bloquearía. Los comandos como `git status` funcionan para el comportamiento predeterminado pero requieren permiso explícito (como `"git status *"`) cuando se pasan argumentos.
+:::