Qwen Code after the closure of qwen-oauth: working via JoinGonka Gateway

Step 1: install Qwen Code. The official methods from the project README:

# 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

The script places the command in ~/.local/bin/qwen and, if needed, appends the path to your shell's config file. Open a new terminal and check: qwen --version.

Step 2: get a key. Sign up at gate.joingonka.ai/register, verify your address, and in the "API keys" section create a key with the jg- prefix.

Step 3: run the installer.

npx @joingonka/setup --tool qwen-code

The installer will ask for your key (it isn't passed as a command-line argument, so it won't linger in your shell history) and will edit ~/.qwen/settings.json — the file that the Qwen Code docs suggest for "single-file" configuration:

• it writes the key into the file's own env block under the name JOINGONKA_API_KEY — the same place the built-in /auth command stores keys; the file gets 600 permissions, and your shell environment stays untouched;
• it adds the network's models to the modelProviders.openai list — with the gateway address, real context windows, and response ceilings; entries from your other providers in that list are preserved;
• if the auth type isn't set or still points to the deprecated qwen-oauth, it switches it to openai and sets DeepSeek V4 Flash as the default model; a working choice of another type — anthropic, gemini, vertex-ai — is left alone unless you pass --model;
• it saves a copy of the previous file, leaves comments and other settings untouched, and finally sends a live request to the gateway to report whether the key, address, and model were accepted.

Here's what the output looked like on an install that still had qwen-oauth (abridged):

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.

A different default model is set with the --model flag: the shorthand glm, minimax, or a full identifier; an explicitly specified model is always written. Non-interactive mode takes the key from an environment variable:

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

A directory moved via the QWEN_HOME variable is found by the installer automatically. Running it again will update the model catalog but keep the network model you selected: Kept your current default model.

Everything the installer does can be done by hand. The file is ~/.qwen/settings.json (or $QWEN_HOME/settings.json); Qwen Code reads it as JSON with comments. Here is a complete working configuration for the Gonka network:

{
  "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" }
}

Where to keep the key. Qwen Code looks up the value of the variable from envKey in order: the shell environment, then the first .env it finds (.qwen/.env or .env from the current directory upward, then ~/.qwen/.env and ~/.env), and only then the env block of the file. Hence the main pitfall: a JOINGONKA_API_KEY exported in the shell with an old value will override the file — we tested this deliberately and got 401 Invalid API key with the correct key in settings.json. The installer warns when it sees a different value in the environment.

And a note on projects: a project-level .qwen/settings.json with its own modelProviders does not extend but replaces the list from the home directory — inside such a project the gateway models will disappear from /model. You should not put the key in the project file at all: along with it, it will end up in the repository.

A running session picks up edits to modelProviders without a restart — just reopen /model. Without an editor, the /auth → Custom Provider wizard does the same.

Qwen Code has two independent choices: authorization type — which protocol to enable and where to get keys from — and model. The type is stored in security.auth.selectedType, and the installer's behavior depends on it:

Inside a session, the model is changed via the /model command. In our run, it showed all gateway records with the protocol label, and below the list — the context window, base URL, and the name of the environment variable for the key:

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

The selection from /model persists between sessions. For a single launch, the model is set via the -m flag with an identifier: qwen -m zai-org/GLM-5.3-Flash. A separate lightweight model for hints and permission classification is set via /model --fast; as long as it is not present, the main model handles this task.

Which model to choose. The price for all models in the network is the same, so the choice is about behavior. This is how they performed in Qwen Code 0.24.4 on the same task — reading a file and finding an error (verified September 23, 2026):

Reasoning in GLM-5.3 Flash. The installer provides samplingParams to each model, but in this case, Qwen Code does not add a reasoning level to the request: the /effort command does not reach network models, and GLM-5.3 Flash always thinks. If you need a switch, declare the levels directly in the model record:

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

Then Qwen Code will start sending reasoning_effort, and for GLM-5.3 Flash, the low value turns off reasoning entirely — see the model overview for details. In our run with "defaultEffort": "low", Qwen Code sent reasoning_effort: "low", and the model responded without a reasoning block.

The fastest check is a one-off run. Put a calc.py with an addition function that actually subtracts into an empty directory, and ask it to find the bug:

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

The agent should call the read tool on its own and answer to the point. Here's how GLM-5.3 Flash answered (run with -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`.

In the interface (qwen with no arguments), the header will show the selected model — API Key | DeepSeek V4 Flash (Gonka) — and the same request will run like this:

> 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

The /stats command shows requests and tokens by model, and the gateway dashboard shows the same usage in the "Usage" section.

Approval mode in -p. Without flags, a one-off run goes into Ask Permissions mode: there's no one to confirm, so tools that require permission — shell commands, file editing and writing — are simply not passed to the model. When asked to run ls, the agent in our run replied that it didn't have such a tool. For edits, add --approval-mode auto-edit; for commands, --yolo; the latter comes with a warning from Qwen Code that the sandbox is not enabled.

If something goes wrong, the diagnosis is usually readable right from the message:

Agents consume tokens differently than chat: for every phrase of yours, Qwen Code adds a system prompt and tool descriptions, and tasks take multiple turns. In our run, each qwen -p query carried about 13 thousand input tokens even before getting to the point, and “read the file, find the error” took two turns and about 27 thousand tokens. The interface has more tools, and after answering, Qwen Code performs service requests using the same model—for example, for follow-up suggestions: /stats showed 4 requests and about 79 thousand input tokens for the same task.

Through JoinGonka Gateway, tokens cost $0.0069 per million for input and $0.021 per million for output—the price is the same for all network models and is pulled onto this page from a live source.

The estimates in the right column are based on September 2026 prices. For comparison—how you can pay for models in Qwen Code in general:

Service requests can be disabled where not needed: follow-up suggestions — "ui": { "enableFollowupSuggestions": false }, background auto-memory — "memory": { "enableManagedAutoMemory": false, "enableManagedAutoDream": false }. Precise consumption and balance are available in the dashboard, in the “Usage” and “Billing” sections. Why DeepSeek V4 Flash is selected by default is explained in detail in the model overview.

Approval modes. In the Qwen Code interface, it starts in Auto mode: reading, searching, and editing within the project are allowed immediately, while shell commands and other risky actions are evaluated by a classifier—a separate request to the model. Other modes—Plan, Ask Permissions, Auto-Edit, and YOLO—can be cycled via Shift+Tab (in Windows — Tab) or the /approval-mode command; the default mode is set by the tools.approvalMode key.

Background work. By default, Qwen Code maintains auto-memory: after conversations, it extracts notes about the project and your preferences in the background, and clears them once a day (Dream)—using the same model. In a single run, this is noticeable: qwen -p might not finish for a few more minutes after answering while a background task is waiting for the model. For scripts and CI, turn off auto-memory (keys above) and set run limits: --max-wall-time, --max-session-turns, --max-tool-calls.

Images. The network models are text-based (Modality: text-only in /model). For screenshots, assign a mediator model from another provider using the /model --vision command: it will describe the image in text, and the main model will continue working.

Statistics. Qwen Code sends anonymous usage statistics by default; it is disabled by "privacy": { "usageStatisticsEnabled": false }. The gateway does not store the content of prompts and responses—only consumption aggregates.

Network neighbors. Laboratories whose models the network serves also release their own agents: DeepSeek has DeepSeek Harness, MiniMax has MiniMax Code, and Z.ai (the authors of GLM) has ZCode. All of them connect to the same gateway with the same key and consume the same balance.