Qwen Code após o fim do qwen-oauth: trabalhando via JoinGonka Gateway

Passo 1: instalar o Qwen Code. Os métodos oficiais do README do projeto:

# Linux and macOS: standalone build with its own Node.js
curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh | bash

# Windows (PowerShell)
irm https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1 | iex

# npm (requires Node.js 22 or newer)
npm install -g @qwen-code/qwen-code@latest

# Homebrew
brew install qwen-code

O script coloca o comando em ~/.local/bin/qwen e, se necessário, acrescenta o caminho ao arquivo de configuração do shell. Abra o terminal de novo e confira: qwen --version.

Passo 2: obter uma chave. Cadastre-se em gate.joingonka.ai/register, confirme o endereço e crie na seção «Chaves de API» uma chave com o prefixo jg-.

Passo 3: rodar o instalador.

npx @joingonka/setup --tool qwen-code

O instalador vai pedir a chave (ela não é passada como argumento de linha de comando para não ficar no histórico do shell) e vai editar o ~/.qwen/settings.json — o arquivo que a documentação do Qwen Code sugere para configurar «em um único arquivo»:

• grava a chave no bloco env do próprio arquivo com o nome JOINGONKA_API_KEY — é ali que o próprio comando /auth também coloca as chaves; o arquivo recebe permissões 600 e o ambiente do shell não muda;
• adiciona os modelos da rede à lista modelProviders.openai — com o endereço do gateway, janelas de contexto reais e tetos de resposta; as entradas dos seus outros provedores nessa lista são preservadas;
• se o tipo de autorização não estiver escolhido ou ainda apontar para o qwen-oauth já encerrado, muda para openai e define DeepSeek V4 Flash como modelo padrão; uma escolha funcional de outro tipo — anthropic, gemini, vertex-ai — não é alterada sem a flag --model;
• salva uma cópia do arquivo anterior, não mexe nos comentários nem nas demais configurações e, no fim, envia uma requisição real ao gateway e informa se a chave, o endereço e o modelo foram aceitos.

Era assim a saída em uma instalação em que ainda havia qwen-oauth (resumida):

Configured ~/.qwen/settings.json
Base URL: https://gate.joingonka.ai/v1
Default model: deepseek-ai/DeepSeek-V4-Flash-0731 (replaces qwen-oauth — that free tier was discontinued on 2026-04-15)
Switched Qwen Code to JoinGonka (auth type "openai") — this replaced your previous auth type "qwen-oauth".
To go back: run /auth (and /model) inside Qwen Code, or restore ~/.qwen/settings.json.bak.2026-09-23T04-22-32-159Z.
…
✓ Verified: the gateway accepted the key, base URL and model.

Outro modelo padrão é definido pela flag --model: o atalho glm, minimax ou o identificador completo; o modelo indicado explicitamente é sempre gravado. O modo sem perguntas pega a chave de uma variável de ambiente:

JOINGONKA_API_KEY=jg-your-key npx @joingonka/setup --tool qwen-code --model glm --non-interactive

O instalador encontra sozinho o diretório alterado pela variável QWEN_HOME. Uma nova execução atualiza o catálogo de modelos, mas mantém o modelo de rede que você escolheu: Kept your current default model.

Tudo o que o instalador faz pode ser escrito à mão. O arquivo é ~/.qwen/settings.json (ou $QWEN_HOME/settings.json); o Qwen Code o lê como JSON com comentários. A configuração funcional para a rede Gonka, completa:

{
  "env": { "JOINGONKA_API_KEY": "jg-your-key" },
  "modelProviders": {
    "openai": [
      { "id": "deepseek-ai/DeepSeek-V4-Flash-0731", "name": "DeepSeek V4 Flash (Gonka)",
        "baseUrl": "https://gate.joingonka.ai/v1", "envKey": "JOINGONKA_API_KEY",
        "generationConfig": { "contextWindowSize": 380000, "samplingParams": { "max_tokens": 32768 } } },
      { "id": "zai-org/GLM-5.3-Flash", "name": "GLM 5.3 Flash (Gonka)",
        "baseUrl": "https://gate.joingonka.ai/v1", "envKey": "JOINGONKA_API_KEY",
        "generationConfig": { "contextWindowSize": 390000, "samplingParams": { "max_tokens": 8192 } } },
      { "id": "MiniMaxAI/MiniMax-M2.7", "name": "MiniMax M2.7 (Gonka)",
        "baseUrl": "https://gate.joingonka.ai/v1", "envKey": "JOINGONKA_API_KEY",
        "generationConfig": { "contextWindowSize": 200000, "samplingParams": { "max_tokens": 8192 } } }
    ]
  },
  "security": { "auth": { "selectedType": "openai" } },
  "model": { "name": "deepseek-ai/DeepSeek-V4-Flash-0731", "baseUrl": "https://gate.joingonka.ai/v1" }
}

Onde guardar a chave. O valor da variável de envKey o Qwen Code procura em ordem: o ambiente do shell, depois o primeiro .env encontrado (.qwen/.env ou .env do diretório atual para cima, depois ~/.qwen/.env e ~/.env) e só então o bloco env do arquivo. Daí a principal armadilha: uma JOINGONKA_API_KEY exportada no shell com um valor antigo vai sobrescrever o arquivo — testamos isso de propósito e obtivemos 401 Invalid API key com a chave correta no settings.json. O instalador avisa quando detecta outro valor no ambiente.

E uma ressalva sobre projetos: um .qwen/settings.json de projeto com seu próprio modelProviders não complementa a lista do diretório pessoal — ele a substitui; dentro desse projeto os modelos do gateway somem de /model. Não vale a pena colocar a chave no arquivo do projeto de jeito nenhum: junto com ele, ela vai parar no repositório.

A sessão em andamento assimila alterações em modelProviders sem reiniciar: basta reabrir /model. Sem editor, o mesmo é feito pelo assistente /auth → Custom Provider.

O Qwen Code possui duas escolhas independentes: tipo de autorização —qual protocolo ativar e de onde obter as chaves— e modelo. O tipo é armazenado em security.auth.selectedType e dele depende como o instalador agirá:

Dentro de uma sessão, o comando /model altera o modelo. Em nossa execução, ele exibiu todas as entradas do gateway com a etiqueta do protocolo e, abaixo da lista, a janela de contexto, a URL base e o nome da variável de ambiente com a chave:

Select Model

  1. [openai] MiniMax M2.7 (Gonka) (MiniMaxAI/MiniMax-M2.7)
› 2. [openai] DeepSeek V4 Flash (Gonka) (deepseek-ai/DeepSeek-V4-Flash-0731)
  3. [openai] GLM 5.3 Flash (Gonka) (zai-org/GLM-5.3-Flash)

Modality:       text-only
Context Window: 380,000 tokens
Base URL:       https://gate.joingonka.ai/v1
API Key:        JOINGONKA_API_KEY

A escolha feita via /model é salva entre sessões. Para uma única execução, o modelo é definido com a flag -m seguida do identificador: qwen -m zai-org/GLM-5.3-Flash. Um modelo leve independente para sugestões e classificação de permissões é definido com /model --fast; enquanto não existir, essa tarefa é realizada pelo principal.

Qual modelo escolher. O preço de todos os modelos da rede é o mesmo, portanto, a escolha depende do comportamento. Assim eles se comportaram no Qwen Code 0.24.4 na mesma tarefa —ler um arquivo e encontrar um erro (verificado em 23 de setembro de 2026):

Raciocínio no GLM-5.3 Flash. O instalador atribui samplingParams a cada modelo e, neste caso, o Qwen Code não adiciona o nível de raciocínio à solicitação: o comando /effort não chega aos modelos da rede, e o GLM-5.3 Flash pensa sempre. Se precisar de um interruptor, declare os níveis diretamente na entrada do modelo:

{
  "id": "zai-org/GLM-5.3-Flash",
  "capabilities": {
    "reasoning": { "profile": "openai-effort", "efforts": ["low", "high"], "defaultEffort": "high" }
  },
  …
}

Então, o Qwen Code começará a enviar reasoning_effort, e no GLM-5.3 Flash o valor low desativa o raciocínio por completo; detalhes na análise do modelo. Em nossa execução com "defaultEffort": "low", o Qwen Code enviou reasoning_effort: "low" e o modelo respondeu sem o bloco de raciocínio.

O teste mais rápido é uma execução única. Coloque em um diretório vazio um calc.py com uma função de soma que na verdade subtrai, e peça para encontrar o bug:

qwen -p "Read calc.py and tell me in one sentence whether it has a bug."

O agente deve chamar por conta própria a ferramenta de leitura e responder com objetividade. Foi assim que o GLM-5.3 Flash respondeu (execução com -m zai-org/GLM-5.3-Flash):

Yes, there is a bug: the `add` function subtracts instead of adding (`return a - b`), so `print(add(2, 3))` prints `-1` instead of `5`.

Na interface (qwen sem argumentos), o cabeçalho mostra o modelo selecionado — API Key | DeepSeek V4 Flash (Gonka) — e o mesmo pedido funciona assim:

> Read calc.py and tell me in one sentence whether it has a bug.
  ✓ Read calc.py, README.md

  ◆ Yes, calc.py has a bug: the add function returns the difference (a - b) instead of the sum (a + b). …

  ➜ demo · DeepSeek V4 Flash (Gonka) · 380.0k Context 5.1% used

O comando /stats mostra as requisições e os tokens por modelo, e o painel do gateway mostra o mesmo consumo na seção «Uso».

Modo de aprovação em -p. Sem flags, a execução única roda em modo Ask Permissions: não há ninguém para confirmar, então as ferramentas que exigem permissão — comandos de shell, edição e escrita de arquivos — simplesmente não são passadas ao modelo. Diante do pedido de executar ls, o agente no nosso teste respondeu que não tinha essa ferramenta. Para edições, adicione --approval-mode auto-edit; para comandos, --yolo; este último o Qwen Code acompanha com um aviso de que a sandbox não está ativada.

Se algo der errado, o diagnóstico geralmente se lê direto na mensagem:

Um agente gasta tokens de forma diferente a um chat: para cada frase sua, o Qwen Code adiciona um prompt de sistema e descrições de ferramentas, e a tarefa leva vários turnos. Em nosso teste, cada consulta qwen -p consumia cerca de 13 mil tokens de entrada antes de entrar no assunto, e a tarefa «leia o arquivo, encontre o erro» levou dois turnos e cerca de 27 mil tokens. Na interface há mais ferramentas, e após a resposta, o Qwen Code usa o mesmo modelo para fazer solicitações auxiliares — por exemplo, sugestão da próxima réplica: /stats mostrou 4 solicitações e cerca de 79 mil tokens de entrada para a mesma tarefa.

Através do JoinGonka Gateway, os tokens custam $0.0069 por milhão de entrada e $0.021 por milhão de saída — o preço é igual para todos os modelos da rede e é fornecido nesta página a partir de uma fonte em tempo real.

As estimativas na coluna da direita são baseadas nos preços de setembro de 2026. Para comparação, como se pode pagar pelos modelos no Qwen Code:

Solicitações auxiliares são desativadas onde não são necessárias: sugestões da próxima réplica — "ui": { "enableFollowupSuggestions": false }, memória automática em segundo plano — "memory": { "enableManagedAutoMemory": false, "enableManagedAutoDream": false }. O consumo exato e o saldo restante estão no painel, nas seções «Uso» (Usage) e «Faturamento» (Billing). Por que o DeepSeek V4 Flash foi escolhido como padrão é analisado em detalhes na revisão do modelo.

Modos de aprovação. Na interface, o Qwen Code inicia no modo Auto: leitura, busca e edições dentro do projeto são permitidas imediatamente, enquanto comandos de shell e outras ações arriscadas são avaliados por um classificador — uma solicitação separada para o modelo. Os outros modos — Plan, Ask Permissions, Auto-Edit e YOLO — são alternados via Shift+Tab (no Windows — Tab) ou comando /approval-mode; o modo padrão é definido pela chave tools.approvalMode.

Trabalho em segundo plano. Por padrão, o Qwen Code mantém uma memória automática: após as conversas, ele extrai notas sobre o projeto e suas preferências em segundo plano, e uma vez por dia as limpa (Dream) — usando o mesmo modelo. Em uma execução única, isso é perceptível: o qwen -p pode não terminar por vários minutos após a resposta, enquanto a tarefa em segundo plano espera pelo modelo. Para scripts e CI, desative a memória automática (chaves na seção acima) e defina limites de execução: --max-wall-time, --max-session-turns, --max-tool-calls.

Imagens. Os modelos da rede são apenas de texto (Modality: text-only em /model). Para capturas de tela, atribua um modelo intermediário de outro provedor usando o comando /model --vision: ele descreverá a imagem em texto, e o modelo principal continuará o trabalho.

Estatísticas. O Qwen Code envia estatísticas de uso anônimas por padrão; desative com "privacy": { "usageStatisticsEnabled": false }. O Gateway não armazena o conteúdo dos prompts e respostas — apenas agregados de consumo.

Vizinhos de rede. Laboratórios cujos modelos são atendidos pela rede também lançam seus próprios agentes: no DeepSeek é o DeepSeek Harness, no MiniMax é o MiniMax Code, e no Z.ai (autores do GLM) é o ZCode. Todos eles se conectam ao mesmo gateway com a mesma chave e consomem um único saldo.