# MiniMax M3.1 Flash in OpenCode: configurazione testata e chiamate tool

> Configurare MiniMax M3.1 Flash in OpenCode v2.2.3: JSON del provider completo, ID del modello, chiamate tool reali e correzioni per errori di chiave e contesto.

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

---

[MiniMax M3.1 Flash](https://omniakey.com/it/minimax-m3-1-flash) funziona in OpenCode v2.2.3 tramite un [provider personalizzato compatibile OpenAI](https://opencode.ai/docs/providers/). Il nome esatto del modello in OpenCode è `omniakey/minimax-m3.1-flash`, la Base URL è `https://api.omniakey.com/v1`, e la configurazione qui sotto ha completato un compito reale su un repository il 12 novembre 2026: cinque letture, una scrittura, un'esecuzione di `node --test` e 12 test su 12 superati.

OpenCode parla il formato OpenAI Chat Completions con un provider personalizzato, e OmniaKey serve quel formato su /v1. Tutto sta in un file di progetto, ma tre dettagli decidono se funziona: l'ID del modello deve seguire la grafia di OmniaKey, la chiave deve arrivare al processo del server OpenCode e la configurazione del provider deve conservare il campo di ragionamento tra una chiamata tool e l'altra.

## Cosa serve prima di iniziare

Usa OpenCode V2. La versione testata è la v2.2.3. La V2 mette i provider personalizzati in un oggetto providers di primo livello; gli esempi della V1 usano un'altra forma. Controlla [la documentazione dei provider V2](https://opencode.ai/docs/providers/) e `opencode --version` prima di copiare la configurazione.

- OpenCode: v2.2.3, testato il 12 novembre 2026.
- ID del modello in OmniaKey: `minimax-m3.1-flash`.
- Riferimento in OpenCode: `omniakey/minimax-m3.1-flash`.

Crea una chiave OmniaKey e mettila in `OMNIAKEY_API_KEY`. Il JSON qui sotto nomina la variabile e non contiene mai il segreto. Scegli un repository piccolo con un comando di test già pronto; il test ha usato un esempio Node con `src/normalize.js`, un file di test e uno script di test.

L'API proprietaria di MiniMax usa l'ID con maiuscole miste `MiniMax-M3.1-Flash`. OmniaKey usa la forma minuscola `minimax-m3.1-flash`. In opencode.jsonc scrivi l'ID minuscolo di OmniaKey in entrambi i punti, la chiave della mappa models e `modelID`; una capitalizzazione diversa non corrisponde all'ID di OmniaKey.

Se stai ancora scegliendo il modello, la [recensione di MiniMax M3.1 Flash](https://omniakey.com/it/blog/minimax-m3-1-flash-review) raccoglie benchmark, informazioni sul rilascio e il ragionamento sempre attivo.

## La configurazione OpenCode V2 che abbiamo testato

Metti questo file nella radice del progetto come opencode.jsonc. È la forma pubblica della configurazione usata nell'esecuzione.

```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"}
  ]
}
```

L'array env dice a OpenCode quale variabile di credenziale leggere: `OMNIAKEY_API_KEY` arriva dall'ambiente del processo server. `modelID` è l'ID inviato a OmniaKey, mentre la chiave nella mappa models è l'ID che OpenCode usa nei riferimenti provider/model. Tenere entrambi su `minimax-m3.1-flash` evita una ricerca ambigua.

I blocchi limit e capabilities sostituiscono [le impostazioni predefinite di OpenCode per un modello sconosciuto](https://opencode.ai/docs/models.md). Senza di essi OpenCode presuppone un contesto di 200.000 token e input di immagini. [La pagina del modello su OmniaKey](https://omniakey.com/it/minimax-m3-1-flash) indica un contesto di 1M token e nessun input visivo, quindi la configurazione fissa il limite a 1.000.000 di token e l'input solo a testo. Il valore 1M è la finestra pubblicata, non una dimensione che questo compito piccolo abbia esaurito.

Il blocco body porta i due valori provati: effort di ragionamento medium e tetto `max_tokens` a 4096. L'elenco effort in capabilities sono i cinque livelli descritti nella guida MiniMax; nel test è stato usato medium.

Il blocco permissions è volutamente stretto per il repository di prova. Nega tutto, poi consente lettura, glob e grep, una modifica a `src/normalize.js`, il comando `node --test` e git diff. Nega anche le directory esterne. Sostituisci il percorso e i comandi con le regole del tuo progetto. Un permesso ampio di modifica o di shell dà all'agente molto più accesso di quanto richieda un compito delimitato.

## Avvio con la chiave nella shell del server

Di solito OpenCode avvia o trova un server condiviso in background. Quel server conserva sessioni, configurazione ed esecuzione degli strumenti, e legge le variabili env del provider dal proprio ambiente. Una chiave esportata in un altro terminale non arriva fin lì. La [documentazione della CLI di OpenCode](https://opencode.ai/docs/cli.md) descrive il server condiviso e l'opzione `--standalone`.

Per una prima esecuzione prevedibile usa un server privato da una shell che ha la chiave:

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

Il comando models testato non accetta un argomento provider. Elenca `omniakey/minimax-m3.1-flash`. Poi esegui un compito. Il test ha usato questo argomento di modello e il blocco prompt qui sotto; sostituisci il segnaposto con il testo esatto:

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

L'opzione `--standalone` avvia un server privato da quella shell, così eredita la chiave e legge la configurazione del progetto. Un server condiviso avviato prima vede solo il proprio ambiente. La riga della chiave qui sopra è un segnaposto; il file di configurazione resta senza segreti.

Se hai già un server condiviso in un ambiente con OMNIAKEY\_API\_KEY, puoi usarlo. Quando quell'ambiente non è chiaro, il server privato è la via riproducibile.

## Verifica del ciclo lettura, scrittura e test

Un piccolo esempio Node basta per vedere se le chiamate tool funzionano. L'esempio aveva `src/normalize.js` con uno stub che si limitava a ordinare, un file di test con 12 casi e uno script node --test. Prima della correzione passavano 3 test e 9 fallivano.

Questo è il prompt usato nell'esecuzione, senza modifiche:

```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.
```

L'esecuzione ha prodotto sette operazioni tool in sei richieste HTTP, tutte con risposta 200:

|Strumento|Volte|Cosa ha coperto|
|-|-|-|
|`read`|5|Elenco del repository, sorgente, cartella di test, `package.json`, file di test|
|`write`|1|`src/normalize.js`|
|`shell`|1|`node --test`|

Il primo turno ha inviato due letture in parallelo, una per l'elenco del repository e una per il sorgente. I due turni successivi hanno letto la cartella di test, il file di pacchetto e il file di test. La scrittura ha sostituito il sorgente. La chiamata shell ha eseguito i test. L'esecuzione è durata 70,172 secondi.

La chiamata di test dentro il ciclo ha riportato:

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

La risposta finale ha indicato il file modificato e il risultato 12/12. I sei blocchi usage sommano 20.739 token di input, comprese le letture di prefisso dalla cache, e 803 token di output. Il completion più lungo ha 363 token, quindi il tetto di 4096 non è mai stato raggiunto.

Un processo locale di inoltro ha inviato il corpo della richiesta e la risposta in streaming a OmniaKey senza modifiche. È un compito piccolo: conferma che il ciclo di lettura, scrittura e test funziona in questo repository, non che il modello sia veloce o pulito su qualsiasi codice.

## Impostare effort, contesto e limite di output

Il ragionamento è obbligatorio su M3.1 Flash. [La guida MiniMax alla generazione di testo](https://platform.minimax.io/docs/guides/text-generation.md) dice che il modello pensa sempre, e il [riferimento all'API compatibile OpenAI](https://platform.minimax.io/docs/api-reference/text-openai-api.md) restituisce HTTP 400 se un client invia `thinking: {"type": "disabled"}` o `reasoning_effort: "none"`. Lascia attivo il ragionamento e abbassa l'effort quando vuoi un turno più breve.

|Impostazione|Valore testato|Cosa controlla|
|-|-|-|
|`reasoning_effort`|`medium`|Quanto il modello pensa prima di rispondere|
|`max_tokens`|`4096`|Tetto di output del client per chiamata|
|`limit.context`|`1000000`|Finestra di contesto pubblicata|

`reasoning_effort` accetta low, medium, high, xhigh e max; se omesso, [la guida MiniMax](https://platform.minimax.io/docs/guides/text-generation.md) indica max come predefinito. Medium è bastato per questo compito delimitato. Abbassare l'effort accorcia il ragionamento, ma non lo spegne.

I controlli di campionamento non fanno nulla su questo modello. [Il riferimento API MiniMax](https://platform.minimax.io/docs/api-reference/text-openai-api.md) dice che M3.1 Flash usa sempre 1 e 0,95, quindi togliere temperature e top\_p è più pulito che impostare valori ignorati.

Il contesto di 1M token viene dalla [pagina del modello OmniaKey](https://omniakey.com/it/minimax-m3-1-flash) e dalla [guida MiniMax](https://platform.minimax.io/docs/guides/text-generation.md). Il limite di output di 4096 è un tetto di sicurezza del client scelto per questa esecuzione, non un massimo pubblicato dal fornitore. I token di ragionamento contano dentro quel tetto, quindi un turno di pensiero lungo può finire con `finish_reason: "length"` e poco o nessun testo finale. Abbassa prima l'effort, alza il tetto solo se il compito ha bisogno di più spazio.

## Correggere errori di chiave, ID e continuazione

L'esecuzione riuscita non ha prodotto errori. Questo elenco segue la documentazione collegata di OpenCode e MiniMax. La Base URL esatta è `https://api.omniakey.com/v1`.

|Sintomo|Cosa verificare|Correzione|
|-|-|-|
|`401` o `403`|`OMNIAKEY_API_KEY` è nell'ambiente del server?|Esportala nella shell che avvia OpenCode o usa `--standalone`; tieni la chiave fuori dal JSON.|
|`Model unavailable` o modello non trovato|La chiave della mappa e `modelID` dicono entrambi `minimax-m3.1-flash`?|Correggi grafia e maiuscole; non usare l'ID `MiniMax-M3.1-Flash` del fornitore; verifica che il provider sia attivo.|
|`404` dal gateway|`settings.baseURL` è esattamente l'indirizzo OmniaKey?|Usa la Base URL esatta qui sopra e togli qualsiasi percorso in più.|
|`400` su adaptive thinking|Un client ha inviato ragionamento disattivato o `reasoning_effort: "none"`?|Rimuovilo e abbassa l'effort.|
|Si ferma dopo la prima chiamata tool|Il campo di ragionamento è configurato? La cronologia lo include?|Imposta `reasoningField` su `"reasoning_content"` e ripeti lo stesso prompt.|
|Contenuto vuoto, `finish_reason: "length"`|Il ragionamento consuma il tetto di output?|Abbassa prima l'effort, poi alza `max_tokens`.|
|Errore di contesto su un prompt da 300K|OpenCode usa ancora il valore predefinito di 200K?|Imposta `limit.context` a `1000000` e accorcia il prompt.|
|Input immagine o PDF non riuscito|La pagina OmniaKey elenca la visione?|Invia solo testo e converti prima il file.|

La continuazione può fallire per la configurazione anche quando sembra un problema del modello. [Il riferimento API MiniMax](https://platform.minimax.io/docs/api-reference/text-openai-api.md) chiede di aggiungere la risposta completa dell'assistant ai turni successivi, inclusi `tool_calls` e il ragionamento restituito in `reasoning_content`. [L'impostazione reasoningField di OpenCode](https://opencode.ai/docs/models.md) legge quel campo dallo stream e lo ripristina quando invia la cronologia.

In questa esecuzione ogni richiesta successiva ha portato il campo `reasoning_content` nei messaggi di chiamata tool dell'assistant, le sei richieste si sono chiuse e ogni risultato tool è entrato nel turno seguente.

## Costo, permessi e passi successivi

OmniaKey fattura per token secondo le tariffe attuali nella pagina del modello. Le sei chiamate hanno usato 20.739 token di input, comprese le letture di prefisso dalla cache, e 803 token di output. Per stimare un compito simile, separa l'uso in input senza cache, input letto dalla cache e output, poi moltiplica ogni parte per la tariffa corrente. Il totale di input non si moltiplica per una tariffa unica.

Nel tuo repository parti dalla regola che nega tutto e aggiungi solo le cartelle e i comandi che il compito richiede. Tieni il permesso di modifica sui file che il compito cambia e quello di shell sul comando di test. Questa è la parte che si riscrive in ogni progetto; i blocchi provider e modello possono restare come sono.

Lo stesso schema di chiave e Base URL vale per altri client. La [guida alla configurazione di Claude Code](https://omniakey.com/it/blog/claude-code-setup) di OmniaKey copre quel client, e la [documentazione sugli agenti di coding](https://docs.omniakey.com/en/coding) elenca i passaggi per strumento.

## Domande frequenti

### Questa configurazione funziona su OpenCode V1?

La versione testata è OpenCode v2.2.3 e la configurazione usa l'oggetto providers al plurale della V2. Le pagine della V1 hanno un'altra forma, quindi controlla la versione prima di copiarla su un'installazione vecchia.

### `opencode --standalone models` richiede un filtro provider?

No. Il comando testato è esattamente `opencode --standalone models`, senza argomento provider. Elenca `omniakey/minimax-m3.1-flash`.

### Posso inviare immagini o PDF a questo modello tramite OmniaKey?

La pagina del modello OmniaKey non elenca la visione e la configurazione testata dichiara solo input di testo. Invia testo e converti prima immagini o PDF. Il modello originale MiniMax accetta immagini, ma questo non aggiunge input di immagini alla pagina del modello OmniaKey.

### Posso alzare `max_tokens` sopra 4096?

Sì, il tetto del client può salire. 4096 è il valore testato e le pagine attuali non indicano un massimo fisso per questo modello. Il ragionamento conta dentro il tetto, quindi attenzione a tagli per lunghezza o contenuto vuoto; abbassa prima l'effort, poi alza il tetto.

## Fonti verificate

- [OpenCode Providers](https://opencode.ai/docs/providers/) — verificato il 12 novembre 2026
- [OpenCode Models](https://opencode.ai/docs/models.md) — verificato il 12 novembre 2026
- [OpenCode CLI](https://opencode.ai/docs/cli.md) — verificato il 12 novembre 2026
- [Guida MiniMax alla generazione di testo](https://platform.minimax.io/docs/guides/text-generation.md) — verificato il 12 novembre 2026
- [Riferimento API compatibile OpenAI di MiniMax](https://platform.minimax.io/docs/api-reference/text-openai-api.md) — verificato il 12 novembre 2026
- [OmniaKey: MiniMax M3.1 Flash](https://omniakey.com/it/minimax-m3-1-flash) — verificato il 12 novembre 2026
