Come configurare CometAPI in OpenCode

TL;DR

Configura CometAPI una sola volta in OpenCode, poi seleziona Claude, GPT o DeepSeek per il tuo task di programmazione. Questa guida amplia la guida ufficiale di integrazione CometAPI OpenCode fino a un setup di progetto completo: una chiave API CometAPI, un file di configurazione con tre esempi di modelli, comandi per cambiare modello e un piccolo task JavaScript con verifica ripetibile.

Punti chiave

• La configurazione di OpenCode con CometAPI richiede un ID provider, una base URL dell’API, una credenziale e un ID modello.
• Usa {env:COMETAPI_KEY} per tenere la chiave API reale fuori da opencode.json.
• Registra gli esempi Claude, GPT e DeepSeek in un unico opencode.json; tutte e tre le voci usano la stessa chiave e lo stesso gateway CometAPI.
• Passa da un provider/modello all’altro in OpenCode senza ottenere chiavi separate Anthropic, OpenAI e DeepSeek.
• Attenzione a variabili d’ambiente mancanti, route API non corrispondenti e prompt di approvazione che possono sembrare richieste bloccate.

Che cos’è OpenCode e perché usarlo con CometAPI?

OpenCode è un agente di coding open source con interfaccia da terminale, app desktop ed estensione IDE. In un progetto può spiegare codice esistente, pianificare una modifica, modificare file ed eseguire comandi con permessi configurati. Questo tutorial usa il flusso da terminale: assegna all’agente un piccolo task di programmazione, rivedi le azioni proposte e verifica i file risultanti con un test locale. Consulta la documentazione ufficiale di OpenCode per installazione e uso.

CometAPI fornisce il layer di accesso ai modelli. Un workflow multi-modello altrimenti implica la gestione di credenziali, fatturazione e impostazioni di connessione tra fornitori. Instradare i modelli supportati tramite un unico account CometAPI offre a questo progetto una chiave e una base URL comuni, mentre OpenCode mantiene il repository e le istruzioni del task. È utile quando si confrontano modelli sullo stesso task o si cambia modello selezionato senza riorganizzare il progetto. Un gateway di aggregazione è opzionale: l’accesso diretto al fornitore può essere adatto a un flusso a fornitore singolo o a specifici requisiti contrattuali. Il vantaggio qui è un accesso multi-fornitore semplificato; i formati API, il comportamento dei modelli e la compatibilità degli strumenti richiedono comunque convalide separate.

CometAPI supporta Chat Completions compatibile con OpenAI ed espone anche altri formati API. L’integrazione ufficiale seleziona un adapter per ciascun formato. Qui, Claude Sonnet 5 usa Messages, GPT-6.1 Sol usa Responses e DeepSeek V4.1 Flash usa Chat Completions, in linea con gli esempi collegati sotto. Tutte le richieste vanno comunque a CometAPI con la stessa chiave. Un nome del fornitore e un formato API descrivono cose diverse; non si deve presumere che un singolo modello accetti ogni formato.

Cosa serve prima di configurare CometAPI in OpenCode?

Usa un terminale, Node.js con npm, un account CometAPI con accesso API e saldo disponibile, e una directory di progetto usa e getta. Gli esempi Bash valgono per macOS, Linux o WSL; gli esempi PowerShell etichettati usano sintassi Windows. Node.js deve essere disponibile nella stessa sessione per il controllo JavaScript più avanti nella guida.

Questo walkthrough usa lo stile di configurazione OpenCode 1. La documentazione ufficiale distingue OpenCode 1 da OpenCode 2; entrambi usano il comando opencode. Registra opencode --version prima di iniziare e usa la documentazione di configurazione per quella major version. Il workflow a tre modelli di seguito è un walkthrough di integrazione con risultati attesi, non una dichiarazione di test end-to-end completato.

Registra CLI, Node.js, npm, sistema operativo e data del test quando esegui gli esempi. L’uso dell’API è addebitato al tuo account CometAPI. I comandi sotto sono un walkthrough pratico con esiti attesi; non si afferma alcun output generato dal modello o un’esecuzione riuscita di integrazione a tre modelli.

node --versionnpm --versionopencode --version

Come configurare CometAPI in OpenCode passo dopo passo?

Step 1: Installa OpenCode

Installa il pacchetto npm ufficiale se OpenCode non è già disponibile. L’installazione non fissata segue la release corrente del pacchetto; registra la versione installata prima di usare la configurazione. Se devi riprodurre l’ambiente della guida sorgente, la versione CLI indicata è 1.18.16.

Installa la CLI OpenCode e mostra la sua versione.

npm install -g opencode-aiopencode --version

Apri un nuovo terminale se l’eseguibile non viene trovato dopo l’installazione. Continua dentro una directory di progetto usa e getta così il primo task dell’agente ha un perimetro chiaro.

Crea ed entra in una directory di progetto.

mkdir cometapi-opencode-democd cometapi-opencode-demo

Step 2: Crea una chiave API CometAPI

Genera una chiave API dal tuo account CometAPI e impostala nello stesso terminale usato per avviare OpenCode. Sostituisci il placeholder in locale. Non fare commit della chiave, non incollarla nei prompt né includerla in log condivisi.

La variabile vale per la shell corrente e i processi lanciati da essa. Non fare screenshot di un token reale. I controlli seguenti indicano se la variabile esiste senza stamparne il valore.

Imposta la chiave CometAPI per la sessione Bash corrente.

export COMETAPI_KEY="YOUR_COMETAPI_KEY"

Imposta la chiave CometAPI per la sessione PowerShell corrente.

$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"test -n "$COMETAPI_KEY" && printf "COMETAPI_KEY is set\n" || printf "COMETAPI_KEY is missing\n"if ([string]::IsNullOrWhiteSpace($env:COMETAPI_KEY)) {  "COMETAPI_KEY is missing"} else {  "COMETAPI_KEY is set"}

Step 3: Crea opencode.json

Crea opencode.json nella root del progetto, oppure usa ~/.config/opencode/opencode.json per rendere le voci disponibili tra progetti. Il file di progetto mantiene questo tutorial auto-contenuto. Usa un singolo oggetto provider contenente le tre voci sotto; se esiste già un oggetto provider, unisci le sue voci invece di creare una chiave JSON duplicata.

Per campi in conflitto, la configurazione di progetto ha la precedenza su quella globale; i campi non in conflitto sono mantenuti. Il file OPENCODE_CONFIG personalizzato è caricato tra configurazione globale e di progetto. Controlla la catena di precedenze documentata se sono presenti impostazioni gestite o inline.

Salva la seguente configurazione completa come opencode.json. Ogni provider legge COMETAPI_KEY dall’ambiente. Il modello predefinito è volutamente omesso così puoi scegliere esplicitamente uno dei tre esempi.

La variante Flash rende esplicito l’esempio richiesto DeepSeek V4.1. Mantieni GPT sull’adapter Responses per l’uso degli strumenti; la guida CometAPI DeepSeek documenta la route Chat Completions usata qui. Ricontrolla disponibilità del modello e permessi nel tuo account prima di eseguire gli esempi.

{  "$schema": "https://opencode.ai/config.json",  "provider": {    "cometapi-messages": {      "npm": "@ai-sdk/anthropic",      "name": "CometAPI Claude",      "options": {        "baseURL": "https://api.cometapi.com/v1",        "apiKey": "{env:COMETAPI_KEY}"      },      "models": {        "claude-sonnet-5": {          "name": "Claude Sonnet 5"        }      }    },    "cometapi-responses": {      "npm": "@ai-sdk/openai",      "name": "CometAPI GPT",      "options": {        "baseURL": "https://api.cometapi.com/v1",        "apiKey": "{env:COMETAPI_KEY}"      },      "models": {        "gpt-6.1-sol": {          "name": "GPT-6.1 Sol"        }      }    },    "cometapi-chat": {      "npm": "@ai-sdk/openai-compatible",      "name": "CometAPI DeepSeek",      "options": {        "baseURL": "https://api.cometapi.com/v1",        "apiKey": "{env:COMETAPI_KEY}"      },      "models": {        "deepseek-v4.1-flash": {          "name": "DeepSeek V4.1 Flash"        }      }    }  },  "permission": {    "edit": "ask",    "shell": "ask"  }}

baseURL corretta: https://api.cometapi.com/v1. baseURL errata: https://api.cometapi.com/v1/chat/completions. L’adapter aggiunge il path dell’endpoint. Unisci l’esempio a un opencode.json esistente senza rimuovere impostazioni non correlate.

Le impostazioni edit e shell richiedono approvazione per modifiche ai file e comandi secondo le regole di permesso correnti di OpenCode. Esegui gli esempi di coding in modo interattivo e ispeziona quelle richieste. OpenCode eredita anche gli accessi al sistema operativo del processo che lo avvia; usa una directory usa e getta per questo esercizio.

Step 4: Verifica la connessione al gateway

Il setup e la verifica opzionali di Gemini sono forniti dopo i controlli di connessione per i tre modelli qui sotto.

L’esempio HTTP seguente verifica direttamente la voce DeepSeek Chat Completions. È un modo utile per isolare la connessione al gateway da OpenCode. Claude e GPT usano le rispettive route selezionate dell’adapter nel passo successivo; cambiare l’ID modello dentro questa richiesta HTTP non cambia automaticamente il suo protocollo.

Invia una richiesta Chat Completions minimale da Bash.

curl --silent --show-error \  --output response.json \  --write-out "HTTP %{http_code}\n" \  https://api.cometapi.com/v1/chat/completions \  -H "Authorization: Bearer $COMETAPI_KEY" \  -H "Content-Type: application/json" \  -d '{"model":"deepseek-v4.1-flash","messages":[{"role":"user","content":"Reply with a short greeting."}]}'

Questo comando usa le opzioni write-out e output di curl per separare lo status HTTP da response.json. Un trasferimento riuscito può comunque contenere un errore HTTP, quindi ispeziona lo status stampato e il corpo JSON. Questo evita di dipendere da --fail-with-body, che richiede curl 7.76.0 o successivo.

Invia la stessa richiesta da PowerShell senza quoting JSON specifico della shell.

$body = @{  model = "deepseek-v4.1-flash"  messages = @(@{ role = "user"; content = "Reply with a short greeting." })} | ConvertTo-Json -Depth 4​$response = Invoke-WebRequest -UseBasicParsing -Method Post `  -Uri "https://api.cometapi.com/v1/chat/completions" `  -Headers @{ Authorization = "Bearer $env:COMETAPI_KEY" } `  -ContentType "application/json" `  -Body $body$response.Content | Set-Content -Encoding UTF8 response.json"HTTP $($response.StatusCode)"

In caso di errore HTTP, PowerShell può generare un’eccezione prima che le ultime due righe vengano eseguite. Acquisisci lo status e i dettagli di errore redatti da quel fallimento; non registrarlo come risposta riuscita.

Risultato atteso per la richiesta DeepSeek: HTTP 200 e testo non vuoto in choices[0].message.content. Ispeziona il file response.json salvato invece di accettare il solo HTTP 200. Le aggiunte seguenti mostrano la forma della risposta e come verificare tutte e tre le route configurate. Gli esempi sono illustrativi; questa revisione non dichiara risultati di test CometAPI live. Una richiesta solo testo non convalida streaming o tool call.

Forma illustrativa della risposta DeepSeek: il saluto, i valori di usage e altri campi dipendono dalla richiesta reale. Il JSON seguente è un esempio volutamente abbreviato, non una risposta API catturata.

{"choices":[{"message":{"role":"assistant","content":"Hello!"}}]}

Dopo una vera richiesta HTTP riuscita, la riga di stato dovrebbe riportare HTTP 200 e response.json dovrebbe contenere testo non vuoto dell’assistente. Conserva status e body effettivi della tua esecuzione; non copiare l’esempio come prova del test.

Step 5: Passa tra Claude, GPT e DeepSeek

I comandi in questo passo dovrebbero restituire i marker richiesti dell’assistente. Testo illustrativo dell’assistente, con banner del terminale, tempi e metadati omessi:

Claude:   CLAUDE_READYGPT:      GPT_READYDeepSeek: DEEPSEEK_READY

Queste righe mostrano solo il contenuto atteso. Non sono una trascrizione di terminale. Registra l’output reale e lo status di uscita del processo per ciascun provider; un marker mancante o una richiesta fallita richiede indagine.

Inizia nella directory contenente opencode.json. Elenca i modelli per ciascun provider configurato, poi invia una breve richiesta testuale a ciascuna voce. Questi comandi cambiano il modello e l’adapter selezionati; la chiave CometAPI e la base URL restano le stesse.

Usa questi comandi per verificare che tutte e tre le voci siano visibili e possano restituire testo.

opencode models cometapi-messagesopencode models cometapi-responsesopencode models cometapi-chat​opencode run --model cometapi-messages/claude-sonnet-5 "Reply exactly with: CLAUDE_READY"opencode run --model cometapi-responses/gpt-6.1-sol "Reply exactly with: GPT_READY"opencode run --model cometapi-chat/deepseek-v4.1-flash "Reply exactly with: DEEPSEEK_READY"

Per il cambio interattivo, avvia opencode, inserisci /models e seleziona CometAPI Claude, CometAPI GPT o CometAPI DeepSeek. OpenCode usa la coppia provider/modello di quella voce. Non servono tre account fornitore o tre chiavi API. Con questa configurazione basata sull’ambiente, non usare /connect per fornire una seconda credenziale; una COMETAPI_KEY mancante va corretta nella shell che avvia il processo.

Esito atteso: ogni richiesta breve restituisce il marker richiesto. Registra il risultato effettivo per ciascun modello. Una voce di modello visibile conferma la registrazione; una risposta testuale riuscita conferma quel percorso di richiesta. Nessuna delle due da sola prova che gli strumenti di file funzionino.

Gemini usa un provider e un protocollo separati. Mantieni le voci Claude, GPT e DeepSeek sopra; unisci la voce seguente all’oggetto provider esistente. La base URL sotto segue la configurazione CometAPI fornita dal revisore. Conferma la route corrente e l’accesso al modello nel tuo account CometAPI prima dell’uso.

L’adapter Google supporta una baseURL personalizzata e invia apiKey usando x-goog-api-key. Vedi il riferimento ufficiale del provider Google per AI SDK. Questo conferma le impostazioni dell’adapter; non prova che un particolare modello Gemini sia abilitato sul gateway CometAPI.

{  "provider": {    "cometapi-gemini": {      "npm": "@ai-sdk/google",      "name": "CometAPI Gemini",      "options": {        "baseURL": "https://api.cometapi.com/v1beta",        "apiKey": "{env:COMETAPI_KEY}"      },      "models": {        "YOUR_GEMINI_MODEL_ID": {          "name": "CometAPI Gemini (account-selected model)"        }      }    }  }}

Sostituisci YOUR_GEMINI_MODEL_ID sia nella chiave JSON sia nel comando sotto con l’esatto ID del modello Gemini abilitato per il tuo account CometAPI. È un placeholder, non un ID modello reale. Unisci questa voce di provider senza duplicare la chiave provider di primo livello e avvia OpenCode dalla stessa shell dove COMETAPI_KEY è impostata.

opencode models cometapi-geminiopencode run --model cometapi-gemini/YOUR_GEMINI_MODEL_ID "Reply exactly with: GEMINI_READY"

Testo atteso dell’assistente: GEMINI_READY. Un modello elencato conferma la registrazione locale; ricevere il marker conferma la richiesta di testo. Salva risposta effettiva e status di uscita. Per validare gli strumenti di coding, avvia opencode --model cometapi-gemini/YOUR_GEMINI_MODEL_ID in una nuova directory usa e getta e ripeti il task greet.cjs/check.cjs qui sotto. Il solo successo testuale non verifica streaming, editing o tool call.

Come eseguire un task di coding con Claude, GPT e DeepSeek?

Usa lo stesso piccolo task per ciascun modello: crea una funzione di saluto, aggiungi un’asserzione ed eseguila. Mantieni tre directory pulite così il secondo modello non può semplicemente riutilizzare i file creati dal primo. Questo verifica il flusso di integrazione senza trasformare l’articolo in una classifica delle performance.

Salva prepare-runs.cjs accanto a opencode.json ed eseguilo una volta. Crea tre nuove directory e copia solo la configurazione condivisa. Si interrompe se una directory di destinazione esiste già, così il lavoro precedente non viene sovrascritto.

const fs = require("node:fs");const path = require("node:path");const root = __dirname;const names = ["claude-demo", "gpt-demo", "deepseek-demo"];const config = path.join(root, "opencode.json");if (!fs.existsSync(config)) throw new Error("Missing opencode.json");for (const name of names) {  if (fs.existsSync(path.join(root, name))) {    throw new Error(`Directory already exists: ${name}`);  }}for (const name of names) {  const dir = path.join(root, name);  fs.mkdirSync(dir);  fs.copyFileSync(config, path.join(dir, "opencode.json"));}node prepare-runs.cjscd claude-demoopencode --model cometapi-messages/claude-sonnet-5# After exiting OpenCode:cd ..cd gpt-demoopencode --model cometapi-responses/gpt-6.1-sol# After exiting OpenCode:cd ..cd deepseek-demoopencode --model cometapi-chat/deepseek-v4.1-flash# After exiting OpenCode:cd ..

Esegui una delle seguenti sessioni per volta, partendo dalla directory del progetto padre. Esci dalla sessione prima di passare all’esempio successivo. In ogni sessione, invia lo stesso task sotto e rivedi le modifiche e i comandi proposti. Node.js deve essere disponibile per il processo che avvia OpenCode.

Chiedi all’agente di creare e verificare una piccola funzione JavaScript.

Create greet.cjs in this directory.Export a function named greet(name) that returns "Hello, " + name + "!".Create check.cjs using node:assert/strict.Assert that greet("Ada") equals "Hello, Ada!".Run node check.cjs and report its actual exit status.Do not modify opencode.json or unrelated files.

Risultato atteso: l’agente richiede le approvazioni configurate, crea entrambi i file e completa node check.cjs con exit status 0. Registra ciò che è realmente accaduto. Ispeziona i file e riesegui tu stesso il controllo; una dichiarazione in prosa di successo non è sufficiente. Se una tool call è rifiutata o malformata, indaga la compatibilità della route separatamente da un’approvazione in sospeso.

File di riferimento e verifica locale

I seguenti file sono un’implementazione di riferimento del task richiesto. Sono stati scritti direttamente per questa guida; non sono presentati come artefatti generati dal modello. Eguagliare il loro comportamento osservabile è la condizione di accettazione per l’esecuzione dell’agente.

function greet(name) {  return "Hello, " + name + "!";}​module.exports = { greet };const assert = require("node:assert/strict");const { greet } = require("./greet.cjs");​assert.equal(greet("Ada"), "Hello, Ada!");node check.cjsprintf "exit=%s\n" "$?"node check.cjs"exit=$LASTEXITCODE"

Verifica di riferimento locale: Windows, Node.js v24.19.0, October 22, 2026; node check.cjs ha restituito exit status 0 senza output su standard output. Questo verifica solo i due file di riferimento. Non convalida installazione OpenCode, accesso CometAPI, prompt di approvazione o tool call del modello.

Tieni un record per modello: provider/modello selezionato, se è arrivata una risposta, se greet.cjs e check.cjs sono stati creati, se sono apparse approvazioni e l’exit code di node check.cjs. Registra i fallimenti come tali; non dedurre un pass dall’implementazione di riferimento.

Proteggi le credenziali e verifica l’affidabilità

Archivia COMETAPI_KEY in una variabile d’ambiente invece che in file di configurazione o log condivisi. Mantieni attive le approvazioni per modifica file e comandi shell e testa nuove configurazioni in un progetto usa e getta.

Verifica separatamente richiesta API diretta, risposta di OpenCode e flusso di modifica file. Registra errori e risultati, riprova solo i fallimenti transitori e ispeziona l’area di lavoro prima di ripetere task interrotti.

CometAPI semplifica il passaggio tra modelli, ma OpenCode non fornisce automaticamente failover cross-modello tramite questa configurazione. Se un modello diventa non disponibile, selezionane manualmente un altro verificato e ripeti il controllo di accettazione.

Quanto costa usare OpenCode con CometAPI?

Prezzi di CometAPI e struttura di fatturazione

CometAPI offre prezzi a consumo senza canoni mensili, addebitando solo l’uso effettivo dell’API. Le tariffe dei modelli ufficiali sono in genere inferiori del 20% rispetto ai prezzi standard dei provider, con ulteriori sconti per volumi. Gli sviluppatori possono accedere a Claude, GPT, DeepSeek e altri modelli tramite un unico account, pagando in base al consumo di token del modello selezionato. Consulta la pagina prezzi di CometAPI per le tariffe attuali.

Per richieste senza caching o commissioni aggiuntive:

Costo = (Token in input × Tariffa input + Token in output × Tariffa output) / 1,000,000

Ad esempio, con tariffe ipotetiche di $1/M token input e $4/M token output, usando 20,000 token in input e 2,000 in output il costo è $0.028. Queste sono tariffe illustrative, non prezzi reali dei modelli.

Registra utilizzo dei token, addebiti totali API, tempo di esecuzione e risultati dei test per ciascun task. Per ridurre i costi, limita il contesto non necessario, usa prompt concisi, evita richieste fallite ripetute e scegli modelli a costo inferiore quando soddisfano gli stessi requisiti di qualità.

Strategie di ottimizzazione dei costi API di OpenCode

Per ridurre i costi OpenCode senza compromettere la qualità del coding, concentrati su selezione del modello, efficienza dei token e richieste API non necessarie.

• Scegli il modello giusto: usa modelli a costo inferiore come DeepSeek per task di coding di routine, riservando Claude o GPT a debugging, refactoring e ragionamento più complessi.
• Riduci il consumo di token: mantieni i prompt concisi, fornisci solo i file rilevanti del progetto ed evita di inviare ripetutamente grandi quantità di contesto del repository.
• Usa il caching dei prompt: sfrutta le funzionalità di caching supportate per contesti ripetuti, come istruzioni del progetto e riferimenti al codice, per ridurre i costi di input.
• Evita retry inutili: correggi errori di configurazione e autenticazione prima di riprovare e rivedi gli output precedenti per prevenire lavoro duplicato.
• Monitora la spesa reale: traccia utilizzo di token, addebiti API e completamento dei task tramite CometAPI. Confronta il costo per task riuscito piuttosto che i prezzi per token.

Insieme ai prezzi scontati e a consumo di CometAPI, queste pratiche aiutano a controllare la spesa mantenendo performance affidabili in OpenCode.

Come estendere la configurazione di CometAPI?

Per aggiungere un altro modello, inserisci il suo ID sotto il provider il cui formato API supporta, oppure aggiungi una nuova voce di provider con l’adapter richiesto. Poi seleziona quel provider/modello tramite /models. Mantieni le credenziali in COMETAPI_KEY e conserva le voci esistenti così il cambio resta un’operazione di selezione.

La guida ufficiale copre quattro formati API, inclusi Gemini. Questo articolo usa le tre voci necessarie per Claude, GPT e DeepSeek. Se più modelli selezionati supportano Chat Completions, possono condividere una mappa models cometapi-chat. Non spostare una route solo Responses o solo Messages in quella mappa solo per ridurre il numero di voci.

Scegli l’adapter in base alla route che intendi chiamare e il modello in base al task di programmazione. Un cambio di fornitore non richiede una nuova chiave CometAPI; un cambio di formato API richiede l’adapter configurato corrispondente.

Come risolvere i problemi di CometAPI in OpenCode?

Segui il primo stadio che fallisce: richiesta HTTP → provider OpenCode → strumenti file. Se HTTP fallisce, ispeziona credenziali, accesso al modello e dettagli endpoint. Se HTTP funziona ma OpenCode fallisce, ispeziona configurazione e ambiente di lancio. Se entrambi i test testuali funzionano ma le azioni sui file falliscono, ispeziona permessi e compatibilità delle tool call.

Quando condividi un problema, includi versione di OpenCode, sistema operativo, ID modello, path dell’endpoint e testo di errore redatto. Escludi chiavi API e contenuti privati del repository. Mantieni la richiesta minima che riproduce il problema così si possono indagare separatamente fallimenti di configurazione e degli strumenti.

FAQ

Perché OpenCode perde la mia chiave CometAPI in un nuovo terminale?

I comandi di export e PowerShell sopra impostano una variabile d’ambiente per la sessione corrente e i suoi processi figli. Un terminale aperto separatamente o un editor già in esecuzione potrebbero non ereditarla. Imposta la chiave nell’ambiente che avvia OpenCode e riavvia quel processo. Per una configurazione persistente, usa la gestione credenziali del tuo ambiente invece di incorporare il segreto in un file del repository.

OpenCode carica automaticamente COMETAPI_KEY da un file .env?

L’espressione {env:COMETAPI_KEY} legge l’ambiente del processo. Creare un file .env non stabilisce automaticamente che la variabile sia stata caricata. Usa la tua shell o un loader di ambiente configurato esplicitamente prima di avviare OpenCode. Diagnostica un valore vuoto nel processo di lancio invece di presumere che il provider non sia disponibile.

Una configurazione globale di OpenCode può cambiare questo setup di progetto?

OpenCode unisce la configurazione invece di sostituire ogni file precedente. Il file di progetto sovrascrive i campi sovrapposti del file globale, mentre le impostazioni globali non correlate rimangono. Un file OPENCODE_CONFIG personalizzato è caricato tra questi. Se il comportamento differisce tra repository, confronta queste fonti e eventuali impostazioni gestite o inline invece di presumere che il file locale sia l’unico input.

Aggiornare la lista dei modelli in OpenCode abilita l’accesso a CometAPI?

No. L’opzione di aggiornamento del modello aggiorna la cache models.dev; non concede accesso all’account né prova che un endpoint accetti un ID modello. Una voce configurata manualmente può essere visibile prima di qualsiasi richiesta riuscita. Usa una richiesta reale per verificare la route e consulta le impostazioni dell’account CometAPI per restrizioni di accesso.

Perché curl funziona mentre OpenCode non riesce a chiamare CometAPI?

I due processi possono caricare credenziali diverse, usare ID modello diversi o inviare shape di richiesta differenti. Innanzitutto riesegui il breve prompt testuale dallo stesso terminale della richiesta HTTP riuscita. Poi confronta base URL del provider, adapter e modello selezionato. Se il semplice testo funziona ma un task agente fallisce, conserva separatamente l’errore relativo agli strumenti; la sola connettività HTTP non dimostra la compatibilità degli strumenti.

Conclusione

Ora disponi di un unico opencode.json con esempi per Claude, GPT e DeepSeek, una credenziale CometAPI condivisa e comandi per cambiare il modello attivo. Usa le brevi richieste testuali per verificare l’accesso, quindi esegui lo stesso task di creazione file in directory separate per convalidare il workflow di coding. Conserva i risultati osservati con i dettagli del tuo ambiente prima di applicare il setup a un repository più grande.