# MiniMax M3.1 Flash en OpenCode: configuración y llamadas a herramientas

> Configura MiniMax M3.1 Flash en OpenCode v2.2.3 con un provider propio: JSON completo, ID del modelo, llamadas a herramientas y errores de clave o contexto.

- Canonical HTML: https://omniakey.com/es/blog/minimax-m3-1-flash-opencode
- Markdown: https://omniakey.com/es/blog/minimax-m3-1-flash-opencode.md
- Published: 2026-11-12 (updated 2026-11-12)
- Author: Kiki, COO at OmniaKey
- Language: es
- Category: API setup
- Reading time: 9 min
- All posts: https://omniakey.com/blog/llms.txt

---

[MiniMax M3.1 Flash](https://omniakey.com/es/minimax-m3-1-flash) funciona en OpenCode v2.2.3 a través de un [provider propio compatible con OpenAI](https://opencode.ai/docs/providers/). El nombre exacto del modelo en OpenCode es `omniakey/minimax-m3.1-flash`, la Base URL es `https://api.omniakey.com/v1` y la configuración de abajo resolvió una tarea real de repositorio el 12 de noviembre de 2026: cinco lecturas, una escritura, una ejecución de `node --test` y 12 de 12 pruebas en verde.

OpenCode habla el formato OpenAI Chat Completions con un provider propio, y OmniaKey sirve ese formato en /v1. Todo cabe en un archivo de proyecto, pero hay tres detalles que deciden si arranca: el ID del modelo tiene que coincidir con la grafía de OmniaKey, la clave tiene que llegar al proceso del servidor de OpenCode y la configuración del provider tiene que conservar el campo de razonamiento entre llamadas a herramientas.

## Lo que necesitas antes de empezar

Usa OpenCode V2. La versión probada fue la v2.2.3. V2 coloca los providers propios en un objeto providers de primer nivel; los ejemplos de V1 tienen otra forma, así que revisa [la documentación de providers de V2](https://opencode.ai/docs/providers/) y `opencode --version` antes de copiar nada.

- OpenCode: v2.2.3, probado el 12 de noviembre de 2026.
- ID del modelo en OmniaKey: `minimax-m3.1-flash`.
- Referencia en OpenCode: `omniakey/minimax-m3.1-flash`.

Crea una clave de OmniaKey y guárdala en `OMNIAKEY_API_KEY`. El JSON de abajo nombra la variable y nunca contiene el secreto. Elige un repositorio pequeño que ya tenga un comando de pruebas; la prueba usó un ejemplo de Node con `src/normalize.js`, un archivo de test y un script de test.

La API propia de MiniMax usa el ID con mayúsculas mezcladas `MiniMax-M3.1-Flash`. OmniaKey usa el minúsculo `minimax-m3.1-flash`. En opencode.jsonc, usa el ID en minúsculas de OmniaKey en los dos sitios, la clave del mapa models y `modelID`; con otra caja no coincide con el ID de OmniaKey.

Si todavía estás eligiendo modelo, la [reseña de MiniMax M3.1 Flash](https://omniakey.com/es/blog/minimax-m3-1-flash-review) reúne sus benchmarks, los datos de lanzamiento y el razonamiento que siempre está activo.

## La configuración de OpenCode V2 que probamos

Coloca esto en la raíz del proyecto como opencode.jsonc. Es la forma pública de la configuración usada en la prueba.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "omniakey/minimax-m3.1-flash",
  "share": "disabled",
  "update": "disable",
  "warming": false,
  "snapshots": false,
  "enabled_providers": ["omniakey"],
  "providers": {
    "omniakey": {
      "name": "OmniaKey",
      "env": ["OMNIAKEY_API_KEY"],
      "package": "@opencode/ai/providers/openai-compatible",
      "settings": {
        "baseURL": "https://api.omniakey.com/v1"
      },
      "models": {
        "minimax-m3.1-flash": {
          "modelID": "minimax-m3.1-flash",
          "name": "MiniMax M3.1 Flash",
          "body": {
            "reasoning_effort": "medium",
            "max_tokens": 4096,
            "stream_options": {"include_usage": true}
          },
          "limit": {
            "context": 1000000,
            "output": 4096
          },
          "capabilities": {
            "tools": true,
            "input": ["text"],
            "output": ["text"],
            "freeform": [],
            "reasoning": {
              "supported": true,
              "effort": ["low", "medium", "high", "xhigh", "max"]
            }
          },
          "compatibility": {
            "reasoningField": "reasoning_content",
            "requireReasoning": true,
            "maxTokensField": "max_tokens"
          }
        }
      }
    }
  },
  "permissions": [
    {"action": "*", "resource": "*", "effect": "deny"},
    {"action": "read", "resource": "*", "effect": "allow"},
    {"action": "glob", "resource": "*", "effect": "allow"},
    {"action": "grep", "resource": "*", "effect": "allow"},
    {"action": "edit", "resource": "src/normalize.js", "effect": "allow"},
    {"action": "shell", "resource": "node --test", "effect": "allow"},
    {"action": "shell", "resource": "git diff *", "effect": "allow"},
    {"action": "external_directory", "resource": "*", "effect": "deny"}
  ]
}
```

El array env indica a OpenCode qué variable de credenciales leer: `OMNIAKEY_API_KEY` llega desde el entorno del proceso del servidor. `modelID` es el ID que se envía a OmniaKey, mientras que la clave del mapa models es el ID que OpenCode usa en las referencias provider/model. Si dejas ambos como `minimax-m3.1-flash`, la búsqueda no se vuelve ambigua.

Los bloques limit y capabilities sustituyen [los valores por defecto de OpenCode para un modelo desconocido](https://opencode.ai/docs/models.md). Sin ellos, OpenCode supone un contexto de 200.000 tokens y entrada de imágenes. [La página del modelo en OmniaKey](https://omniakey.com/es/minimax-m3-1-flash) indica un contexto de 1M tokens y ninguna entrada de visión, así que la configuración fija el límite en `1000000` y la entrada solo en texto. La cifra de 1M es la ventana publicada, no un tamaño que esta tarea pequeña haya agotado.

El bloque body lleva los dos valores que se probaron: esfuerzo de razonamiento medium y un tope de `max_tokens` de 4096. La lista de effort en capabilities son los cinco niveles que describe la guía de MiniMax; el usado en la prueba fue medium.

El bloque permissions es estrecho a propósito para el repositorio de demostración. Deniega todo, luego permite leer, glob y grep, una edición de `src/normalize.js`, el comando `node --test` y git diff. También deniega directorios externos. Cambia las direcciones de archivo y los comandos por las reglas de tu proyecto. Un permiso general de edición o de shell le da al agente mucho más acceso del que necesita una tarea acotada.

## Ejecuta con la clave en el shell del servidor

OpenCode suele arrancar o encontrar un servidor compartido en segundo plano. Ese servidor guarda sesiones, configuración y ejecución de herramientas, y lee las variables env del provider de su propio entorno. Una clave exportada en otra terminal no le llega. La [documentación de la CLI de OpenCode](https://opencode.ai/docs/cli.md) describe el servidor compartido y la opción `--standalone`.

Para una primera ejecución predecible, usa un servidor privado desde un shell que tenga la clave:

```bash
export OMNIAKEY_API_KEY="your-omniakey-api-key"
opencode --standalone models
```

El comando models probado no lleva argumento de provider. Lista `omniakey/minimax-m3.1-flash`. Después lanza una tarea. La prueba usó este argumento de modelo y el bloque de prompt de abajo; sustituye el marcador por el texto exacto:

```bash
# Replace <task prompt> with the text from the prompt block below.
opencode --standalone run --model omniakey/minimax-m3.1-flash '<task prompt>'
```

La opción `--standalone` arranca un servidor privado desde ese shell, así que hereda la clave y lee la configuración del proyecto. Un servidor compartido arrancado antes solo ve su propio entorno. La línea de la clave es un marcador; el archivo de configuración sigue sin secretos.

Si ya tienes un servidor compartido en un entorno con OMNIAKEY\_API\_KEY, puedes usarlo. Cuando ese entorno no está claro, el servidor privado es el camino reproducible.

## Comprueba el ciclo de lectura, escritura y test

Un ejemplo pequeño de Node basta para ver si funcionan las llamadas a herramientas. El ejemplo tenía `src/normalize.js` con un stub que solo ordenaba, un archivo de test con 12 casos y un script node --test. Antes del arreglo pasaban 3 pruebas y fallaban 9.

Este es el prompt usado en la prueba, tal cual:

```prompt
Fix src/normalize.js in this small JavaScript repository. Read the source and existing tests, then implement normalizeIntervals: accept valid half-open numeric intervals [start,end], drop empty intervals, sort them, and merge overlapping or touching ranges. Return fresh arrays without mutating the input. Do not change tests or configuration. Run `node --test` and summarize the result. Work only in this repository; do not read any credentials, network resources or files outside it. Use at most 8 tool calls.
```

La ejecución hizo siete operaciones de herramienta en seis peticiones HTTP, todas con respuesta 200:

|Herramienta|Veces|Qué cubrió|
|-|-|-|
|`read`|5|Listado del repo, fuente, carpeta de test, `package.json`, archivo de test|
|`write`|1|`src/normalize.js`|
|`shell`|1|`node --test`|

El primer turno envió dos lecturas en paralelo, una para el listado del repositorio y otra para la fuente. Los dos turnos siguientes leyeron la carpeta de test, el archivo de paquete y el archivo de test. La escritura reemplazó la fuente. La llamada de shell ejecutó las pruebas. El total fue de 70,172 segundos.

La llamada de test dentro del ciclo informó:

```text
ℹ tests 12
ℹ suites 0
ℹ pass 12
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 52.316459
```

La respuesta final nombró el archivo cambiado y el resultado 12/12. Los seis bloques de usage suman 20.739 tokens de entrada, contando las lecturas de prefijo en caché, y 803 tokens de salida. La completion más larga fue de 363 tokens, así que el tope de 4096 nunca se alcanzó.

Un proceso local de reenvío mandó el cuerpo de la petición y la respuesta en streaming a OmniaKey sin cambios. Es una tarea pequeña: confirma que el ciclo de leer, escribir y probar funciona en este repositorio, no que el modelo sea rápido o limpio en cualquier código.

## Ajusta el esfuerzo, el contexto y la salida

El razonamiento es obligatorio en M3.1 Flash. [La guía de generación de texto de MiniMax](https://platform.minimax.io/docs/guides/text-generation.md) dice que el modelo siempre piensa, y su [referencia de la API compatible con OpenAI](https://platform.minimax.io/docs/api-reference/text-openai-api.md) devuelve HTTP 400 si un cliente envía `thinking: {"type": "disabled"}` o `reasoning_effort: "none"`. Deja el razonamiento activo y baja el esfuerzo cuando quieras un turno más corto.

|Ajuste|Valor probado|Qué controla|
|-|-|-|
|`reasoning_effort`|`medium`|Cuánto piensa antes de responder|
|`max_tokens`|`4096`|Tope de salida del cliente por llamada|
|`limit.context`|`1000000`|Ventana de contexto publicada|

`reasoning_effort` acepta low, medium, high, xhigh y max; si se omite, [la guía de MiniMax](https://platform.minimax.io/docs/guides/text-generation.md) indica que el valor por defecto es max. Medium bastó para esta tarea acotada. Bajar el esfuerzo acorta el razonamiento, pero no lo apaga.

Los controles de muestreo no hacen nada en este modelo. [La referencia de la API de MiniMax](https://platform.minimax.io/docs/api-reference/text-openai-api.md) dice que M3.1 Flash usa siempre 1 y 0.95, así que quitar temperature y top\_p es más limpio que ajustar valores que se ignoran.

El contexto de 1M tokens viene de [la página del modelo en OmniaKey](https://omniakey.com/es/minimax-m3-1-flash) y de [la guía de MiniMax](https://platform.minimax.io/docs/guides/text-generation.md). El límite de salida de 4096 es un tope de seguridad del cliente elegido para esta prueba, no un máximo publicado por el proveedor. Los tokens de razonamiento cuentan dentro de ese tope, así que un turno de pensamiento largo puede terminar con `finish_reason: "length"` y poco o ningún texto final. Baja el esfuerzo primero y sube el tope después si la tarea necesita más espacio.

## Arregla errores de clave, ID y continuación

La ejecución correcta no dio errores. Esta lista sigue la documentación enlazada de OpenCode y MiniMax. La Base URL exacta es `https://api.omniakey.com/v1`.

|Síntoma|Qué revisar|Arreglo|
|-|-|-|
|`401` o `403`|¿Está `OMNIAKEY_API_KEY` en el entorno del servidor?|Expórtala en el shell que arranca OpenCode o usa `--standalone`; deja la clave fuera del JSON.|
|`Model unavailable` o modelo no encontrado|¿La clave del mapa y `modelID` dicen `minimax-m3.1-flash`?|Corrige grafía y caja; no uses el ID `MiniMax-M3.1-Flash` del proveedor; confirma que el provider está activo.|
|`404` de la puerta de enlace|¿`settings.baseURL` es exactamente el endpoint de OmniaKey?|Pon la Base URL exacta de arriba y quita cualquier ruta extra.|
|`400` sobre adaptive thinking|¿Un cliente envió razonamiento desactivado o `reasoning_effort: "none"`?|Quítalo y baja el esfuerzo en su lugar.|
|Se detiene tras la primera llamada|¿Está configurado el campo de razonamiento? ¿El historial lo incluye?|Pon `reasoningField` en `"reasoning_content"` y repite el mismo prompt.|
|Contenido vacío, `finish_reason: "length"`|¿El razonamiento consume el tope de salida?|Baja el esfuerzo primero y luego sube `max_tokens`.|
|Error de contexto con un prompt de 300K|¿OpenCode sigue usando su valor de 200K?|Pon `limit.context` en `1000000` y recorta el prompt.|
|Falla la entrada de imagen o PDF|¿La página de OmniaKey lista visión?|Envía solo texto y convierte el archivo antes.|

La continuación puede fallar en la configuración aunque parezca un problema del modelo. [La referencia de la API de MiniMax](https://platform.minimax.io/docs/api-reference/text-openai-api.md) pide añadir la respuesta completa del assistant a los turnos siguientes, incluidos `tool_calls` y el razonamiento devuelto en `reasoning_content`. [El ajuste reasoningField de OpenCode](https://opencode.ai/docs/models.md) lee ese campo de la respuesta en streaming y lo restaura al enviar el historial.

En esta prueba, cada petición de seguimiento llevó el campo `reasoning_content` en los mensajes de llamada a herramienta del assistant, las seis peticiones terminaron y cada resultado de herramienta alimentó el turno siguiente.

## Coste, permisos y siguientes pasos

OmniaKey cobra por token según las tarifas actuales de la página del modelo. Las seis llamadas usaron 20.739 tokens de entrada, contando las lecturas de prefijo en caché, y 803 tokens de salida. Para estimar una tarea parecida, separa el uso en entrada sin caché, entrada leída de caché y salida, y multiplica cada parte por su tarifa actual. El total de entrada no se puede multiplicar por una sola tarifa.

En tu repositorio, empieza por la regla que deniega todo y añade solo las carpetas y comandos que la tarea necesite. Mantén el permiso de edición en los archivos que la tarea cambia y el de shell en el comando de pruebas. Esa es la parte que se reescribe en cada proyecto; los bloques del provider y del modelo pueden quedarse como están.

El mismo patrón de clave y Base URL vale para otros clientes. La [guía de configuración de Claude Code](https://omniakey.com/es/blog/claude-code-setup) de OmniaKey cubre ese cliente, y la [documentación de agentes de código](https://docs.omniakey.com/es/coding) reúne los pasos de cada herramienta.

## Preguntas frecuentes

### ¿Esta configuración funciona en OpenCode V1?

La versión probada es OpenCode v2.2.3 y la configuración usa el objeto providers en plural de V2. Las páginas de V1 tienen otra forma, así que revisa la versión antes de copiarla en una instalación antigua.

### ¿`opencode --standalone models` necesita un filtro de provider?

No. El comando probado es exactamente `opencode --standalone models`, sin argumento de provider. Lista `omniakey/minimax-m3.1-flash`.

### ¿Puedo enviar imágenes o PDF a este modelo a través de OmniaKey?

La página del modelo en OmniaKey no lista visión y la configuración probada declara solo entrada de texto. Envía texto y convierte antes las imágenes o los PDF. El modelo original de MiniMax acepta imágenes, pero eso no añade entrada de imagen a la página del modelo en OmniaKey.

### ¿Puedo subir `max_tokens` por encima de 4096?

Sí, puedes subir el tope del cliente. 4096 fue el valor probado y las páginas actuales no indican un máximo fijo para este modelo. El razonamiento cuenta dentro del tope, así que vigila un corte por longitud o un contenido vacío; baja el esfuerzo primero y luego sube el tope.

## Fuentes consultadas

- [OpenCode Providers](https://opencode.ai/docs/providers/) — revisado el 12 de noviembre de 2026
- [OpenCode Models](https://opencode.ai/docs/models.md) — revisado el 12 de noviembre de 2026
- [OpenCode CLI](https://opencode.ai/docs/cli.md) — revisado el 12 de noviembre de 2026
- [Guía de generación de texto de MiniMax](https://platform.minimax.io/docs/guides/text-generation.md) — revisado el 12 de noviembre de 2026
- [Referencia de la API compatible con OpenAI de MiniMax](https://platform.minimax.io/docs/api-reference/text-openai-api.md) — revisado el 12 de noviembre de 2026
- [OmniaKey: MiniMax M3.1 Flash](https://omniakey.com/es/minimax-m3-1-flash) — revisado el 12 de noviembre de 2026
