Cline GPT-6 Configuration After 3.0.73: Fix max_completion_Tokens Lanes and Audit the New Defaults

A Cline lane pointed at a GPT-6 model has spent its recent life failing at the HTTP layer, not the reasoning layer. Cline CLI v3.0.73, published 2026-10-17 at 03:59 UTC, fixes exactly that: GPT-6 models such as gpt-6-sol and gpt-6.1-sol now work on OpenAI and Azure OpenAI-compatible endpoints, where previously every request was rejected because Cline sent max_tokens instead of max_completion_tokens. The same release quietly rewrites the defaults for seven providers and flips the Cline provider default back to Claude Sonnet 5.5, which makes this Cline GPT-6 configuration story two jobs in one: restore the broken lanes, then turn every silently changed default into a recorded decision.

Who this is for: an operator or team lead running Cline (CLI or desktop) with an OpenAI API key or an Azure OpenAI deployment in reach. Prerequisites are a Cline install at CLI 3.0.73 or desktop 0.0.48 or later, provider settings access, and one working lane to test against. By the end you will have working GPT-6 lanes on both endpoint shapes, a saved copy of the pre-fix rejection signature for future diagnosis, and a completed default-model register covering every provider the catalog refresh touched — the full worked example, with every cell filled, is in the worked-example section below, ready to copy and adapt. For background on where Cline sits among open-source harnesses, see the open-source harness roundup; for the general discipline of catching default drift at upgrade time, read the CLI upgrade canary guide. This guide owns the narrower, nastier lesson: the parameter dialect your harness speaks to an OpenAI-compatible endpoint, and what to do the week it changes.

The two jobs feel unrelated until you notice they share a root cause: Cline, like every OpenAI-compatible client, emits a fixed request shape you do not control, and the vendor on the other end decides which shapes survive. When OpenAI introduced the newer parameter name for its newer model family, the harness had to follow; when the catalog refreshes, unpinned lanes follow the recommended list. In both cases the operator’s only real lever is version discipline and explicit pinning — which is why this guide spends more time on verification, reproduction and registers than on clicking through settings.

Verify the build before touching settings

The fix is version-gated, so confirm the build before debugging anything else. The GitHub Releases API record pins the fact: tag cli-v3.0.73, published_at 2026-10-17T03:59:11Z, created 54 minutes earlier at 03:05:35Z, authored by github-actions[bot], neither draft nor prerelease (API record). Desktop 0.0.48 shipped the same morning at 04:34 UTC with 16 assets, with signed installers publishing SHA-256 values and .sig sidecars — a Windows setup executable, amd64 and arm64 .deb packages, an aarch64 .rpm, and macOS universal builds (desktop release).

The verification pass is short:

1. Open the CLI or desktop About/version surface and read the exact version string; anything below CLI 3.0.73 or desktop 0.0.48 cannot send max_completion_tokens for GPT-6 ids and will keep rejecting.
2. Upgrade through your normal channel, then re-read the version string; do not trust the updater’s completion message alone.
3. Record the version next to each lane in your register — one lane on 3.0.72 and one on 3.0.73 in the same fleet is the most common way this failure survives the fix.
4. Desktop operators downloading manually: match the published SHA-256 of the installer artifact you fetched against the value listed on the release page before installing.
5. Expected observation: the version string reads 3.0.73 (CLI) or 0.0.48 (desktop) or higher. If it does not, stop — every step below assumes the fixed build.

Two fleet realities make this step worth doing slowly. First, mixed fleets are the norm: a teammate’s laptop that auto-updates on a different schedule, a CI runner image pinned to last month’s CLI, a shared VM nobody reboots. Each is a lane, and each needs its own version reading. Second, the version string is the only artifact that ties your lane to the documented fix; everything downstream — the rejection you no longer see, the default that moved — is inferred from it. Thirty seconds per lane now saves an afternoon of misdiagnosis later, because a lane still rejecting max_tokens after “the fix” is almost always a lane still running the old build.

Reproduce and file the rejection signature

Before fixing the lane, capture what the failure looked like, because the same signature will appear in other tools. The mechanism, in Cline’s own words from the sibling SDK v0.0.95 release: OpenAI-compatible requests for GPT-6 ids — gpt-6-sol, gpt-6.1-sol, gpt-6-1-sol, and later gpt-5 through gpt-9 ids — send max_completion_tokens instead of max_tokens, so OpenAI and Azure no longer reject them, while Azure’s gpt-35-turbo keeps max_tokens (releases index). In other words, the newer GPT-6 chat ids accept one parameter name and reject the other, and some older models on the same Azure surface still want the old name. That is a request-dialect mismatch: the model was fine, the key was fine, the quota was fine — one JSON field name killed every request.

How to recognize the class in any OpenAI-compatible tool:

1. The error is a request-level rejection (an HTTP 4xx from the endpoint, typically a 400 with an invalid-parameter style body), not a timeout, rate limit or auth failure.
2. The error names a parameter — max_tokens — rather than a model, key or quota.
3. It reproduces on every request to one model family while other models on the same key and base URL succeed.
4. It survives key rotation, base-URL retyping and tool reinstalls, because none of those change the field name the client emits.

Observation	Points to	First move
400 naming max_tokens, one GPT-6 model only	Parameter-dialect mismatch	Upgrade the client; do not touch the key
401/403 on every model	Credential or header dialect	Check key and auth header form
404 on one model id	Retired or misnamed deployment	Verify the deployment or model id
429 across models	Quota or rate limit	Back off; not a configuration bug

If you have a pre-fix failure log, paste the exact rejection text into your register now and date it. If you already upgraded and the log is gone, note that too — the diagnostic artifact this week is the absence of a rejection you used to have, plus a successful GPT-6 response. The worked example below shows a filled artifact slot with a representative body, labeled illustrative because it is a pattern, not a capture from this article’s reporting.

Why file the signature at all, when the fix has already shipped? Because this failure class is not Cline-specific and it will return. Every OpenAI-compatible client — gateways, eval harnesses, internal wrappers, the long tail of tools that hardcode max_tokens — faces the same split the moment a provider deprecates a parameter name for a model family. The operator who can glance at a 400 body and say “this names a parameter, it hits one family only, it survived a key rotation — it’s a dialect mismatch, upgrade the client” resolves the next occurrence in minutes. The operator who starts with the key and the base URL spends an hour there first, because auth and URL errors are more familiar. Keep the saved rejection text with the lane’s notes; it is the ground truth the next incident will be compared against.

Configure GPT-6 on the OpenAI provider

On the direct OpenAI provider the configuration burden is minimal because the endpoint is fixed by the provider: pick the model, supply the key, and let 3.0.73 emit the correct dialect.

1. Open provider settings and select the OpenAI provider.
2. Enter the API key for the account that holds GPT-6 access.
3. Select gpt-6-sol or gpt-6.1-sol explicitly from the model list — do not leave the model unset, because an unset model falls to the provider default, which is a separate decision covered below.
4. Run one small task in a scratch directory; something with a single file read and a one-line edit is enough to force a real completion request.
5. Expected success: the task completes, no invalid-parameter rejection appears, and the model indicator shows the GPT-6 id you selected.
6. Expected failure worth keeping: if the error names a different parameter or a permission, that is a new issue — file it separately rather than assuming the fix failed.

The choice that matters here is pinning. An explicitly selected model survives every future catalog refresh untouched; an unpinned lane inherits whatever default the next release promotes. Pin the lanes whose behavior or cost you depend on, and leave unpinned only the lanes you have consciously delegated to Cline’s recommended list.

The scratch task deserves one sentence of justification: a trivial prompt that can be answered from the system message alone may never trigger a completion-parameter-bearing request path the same way a tool-using turn does. A file read plus an edit forces the agent loop — request, tool call, follow-up request — which is exactly the traffic that was dying before the fix. If your verification task passes without exercising a second turn, verify again with one that does; the point is to prove the dialect, not to prove the model can chat.

Interpreting what you see: a clean run on 3.0.73 with the GPT-6 id pinned means two things at once — the endpoint accepted the request shape, and your lane is now immune to the next default flip. If cost matters to the lane, note the task’s token usage from the run; that number becomes the baseline row in your register, and the comparison point the next time a default or a model version moves under you. Operators who skip the baseline end up arguing from invoices later, which is a worse place to start.

Configure GPT-6 against an Azure OpenAI-compatible endpoint

Azure OpenAI-compatible endpoints add three inputs the direct provider hides: the endpoint base URL, the deployment name, and an auth header dialect. Microsoft’s reference fixes the shapes: data-plane requests go to paths of the form https://{endpoint}/openai/deployments/{deployment-id}/... with an api-version query parameter in YYYY-MM-DD form, and authenticate either with an api-key HTTP header or a Bearer Microsoft Entra token (Azure OpenAI reference). Get any one of the three wrong and the failure will look nothing like the parameter bug, which is why this section is worth doing slowly once.

The filled settings block for the worked example fleet, with the concrete values lane 4 of the register actually uses:

Provider:      OpenAI Compatible
Base URL:      https://aoai-prod-eus.openai.azure.com/openai/deployments/gpt6-sol-dev/chat/completions
API key:       32-char Azure OpenAI resource key (one of the two from the resource's Keys page)
Auth header:   api-key
Model (id):    gpt-6.1-sol
api-version:   appended as ?api-version=<current GA YYYY-MM-DD> if your gateway does not add it

How each input was chosen, and what a mistake looks like:

Input	Why this value	If wrong, you see
Base URL	Resource endpoint plus /openai/deployments/ plus your deployment id	404 — the path does not resolve to a deployment
Deployment id	The name you gave the deployment in Azure, not necessarily the model name	404 naming the deployment, or a different model answering
api-key header	Documented Azure key authentication for data-plane calls	401 — the endpoint expects the Azure header, not Bearer sk-...
Pinned gpt-6.1-sol	Survives catalog refreshes; exercises the fixed dialect	Silent drift to a different default model

Steps to bring the lane up:

1. In Azure, confirm the deployment exists and note its exact deployment id; the model version behind it is a separate fact from the id you type.
2. In Cline, configure the OpenAI Compatible provider with the base URL, key and header dialect exactly as in the block above.
3. Pin gpt-6-sol or gpt-6.1-sol as the model.
4. Run the same scratch task as the direct lane.
5. Expected success on 3.0.73 or later: the request completes without the max_tokens rejection that killed it before the fix.
6. Expected failure signatures and their meaning: 401 means header or key dialect; 404 means base URL or deployment id; a 400 naming max_tokens on an old build means the version check in the first section was skipped.

To isolate the dialect without involving Cline at all, probe the documented request shape directly. The two illustrative requests below follow the Azure reference’s documented path, header and api-version forms; substitute your own resource, deployment, key and a current GA api-version, and expect the parameter-name rejection to appear only in the first variant (Azure OpenAI reference):

# Illustrative probe A — old dialect, expect a 400 naming max_tokens on GPT-6 ids
curl -s -o - -w "\nHTTP %{http_code}\n" \
  "https://aoai-prod-eus.openai.azure.com/openai/deployments/gpt6-sol-dev/chat/completions?api-version=2024-06-01" \
  -H "api-key: $AZURE_OPENAI_KEY" -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"dialect probe"}],"max_tokens":64}'

# Illustrative probe B — new dialect, expect HTTP 200 with choices in the body
curl -s -o - -w "\nHTTP %{http_code}\n" \
  "https://aoai-prod-eus.openai.azure.com/openai/deployments/gpt6-sol-dev/chat/completions?api-version=2024-06-01" \
  -H "api-key: $AZURE_OPENAI_KEY" -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"dialect probe"}],"max_completion_tokens":64}'

Read the pair as one experiment: if probe A returns a 400 whose body names max_tokens and probe B on the same key, deployment and api-version returns 200, you have proven the key, header, base URL, deployment and quota are all good, and the only variable left is the parameter name. That is the cleanest possible evidence that a failing client is a dialect problem, not a configuration problem — record both outcomes in your register as the reproduction record. If both probes fail identically, the fault is upstream of the dialect and the status-code table in the previous section applies. These probes are illustrative of the documented request shape; the outcomes described are the expected pattern for the documented dialect split, not results observed while reporting this article. The api-version date shown is the reference page’s own example value — use your service’s current GA version.

One Azure-specific nuance from the SDK notes: gpt-35-turbo on Azure keeps max_tokens. If you operate a mixed lane with both a GPT-6 id and a legacy gpt-35-turbo deployment, do not be surprised that the two models accept different dialects on the same service — the client, not the endpoint, adapts. This is also the sharpest diagnostic separation available to you: when one deployment on a key works and another rejects with a parameter error, the endpoint, key and header are all proven good, and the difference collapses to model-versus-dialect. That observation, written into the register, is what lets you tell a platform incident from a client bug without opening a support ticket.

A note on the deployment id, because it wastes more operator time than any other field: Azure lets you name a deployment anything, and teams routinely name it after the model, a version suffix, or an environment. Whatever your convention, the value in the base URL must match the deployment name exactly, character for character, while the model id you pin in Cline identifies the model family. Two names, two jobs. When a 404 arrives, check the deployment name in the Azure portal against your base URL before touching anything else; a stale deployment name from a redeployed resource is a far more common cause than a retired model.

The worked example: one fleet, six lanes, every cell filled

This section is the deliverable, and this time every cell is filled. The register below is a complete worked example for a six-lane fleet: a small team with two laptops, one CI runner, and three shared lanes. The old-model cells come from the team’s own pre-upgrade readings on 2026-10-16 where they had them, and from the release history where they did not — each row says which. The decisions in the right-hand columns are a worked editorial example for a cost-sensitive fleet; your own pricing and evals override them, but every row ends with a recorded decision, a check to run, and a dated artifact. Copy the block into your fleet notes and edit the values you read from your own screens.

Default-model register — recorded 2026-10-17, after Cline CLI 3.0.73
Fleet: 6 lanes (3 pinned, 3 deliberately unpinned)

Lane 1 — Cline provider, unpinned (laptop A, owner: Priya)
  Build:      CLI 3.0.73 (version string verified 2026-10-17 09:10 ET)
  Old model:  Gemini 4 Argon (read from settings 2026-10-16; inherited from the 3.0.72-era flip)
  New model:  Claude Sonnet 5.5 (3.0.73 restoration, per release note)
  Decision:   KEEP new — scratch lane, wants the recommended list
  Check:      none required; change accepted without eval
  Cost note:  none tracked; lane is unmetered experimentation

Lane 2 — Cline provider, previously unpinned (CI runner image ci-agent-14)
  Build:      CLI 3.0.72 → 3.0.73 (image rebuilt 2026-10-17, version string verified in build log)
  Old model:  Gemini 4 Argon (read from the runner's settings export 2026-10-16)
  New model:  Claude Sonnet 5.5
  Decision:   PIN Claude Sonnet 5.5 — CI prompts and rubric tuned to it
  Check:      one scratch task green post-pin; baseline usage 41k input / 6k output tokens recorded
  Cost note:  baseline saved as the comparison point for the next refresh

Lane 3 — OpenAI provider, GPT-6 (laptop B, owner: Marcus)
  Build:      CLI 3.0.73
  Model:      gpt-6-sol (pinned at configuration time)
  Old state:  every request rejected pre-3.0.73; exact 400 body filed in the artifact slot below
  New state:  scratch task (read src/config.ts, edit one default) completed 2026-10-17; no rejection
  Decision:   KEEP, pinned
  Check:      token usage from the scratch run recorded as the cost baseline
  Cost note:  12k input / 3k output tokens on the verification task

Lane 4 — Azure OpenAI-compatible, GPT-6 (shared VM buildbox)
  Build:      CLI 3.0.73
  Base URL:   https://aoai-prod-eus.openai.azure.com/openai/deployments/gpt6-sol-dev/chat/completions
  Header:     api-key
  Model:      gpt-6.1-sol (pinned)
  Old state:  rejected pre-3.0.73
  New state:  dialect probes run — max_tokens variant 400, max_completion_tokens variant 200; task green
  Decision:   KEEP, pinned
  Check:      deployment id gpt6-sol-dev matched the portal entry character for character
  Cost note:  probe pair cost under 200 tokens total; recorded as reproduction evidence

Lane 5 — 302.AI, unpinned (laptop A secondary profile)
  Build:      CLI 3.0.73
  Old model:  Claude Haiku 5.5 (not read locally pre-upgrade; taken from the v4.1.24-era release note listing 302.AI among providers redefaulted then)
  New model:  Gemini 4 Argon (per the 3.0.73 release note)
  Decision:   KEEP new with a check — lane is used for drafting, not review
  Check:      one drafting task run on 2026-10-17; output compared against the team's rubric
  Cost note:  watch the first invoice line after the switch; no baseline existed

Lane 6 — Scaleway, unpinned bulk lane (shared VM, docs-generation cron)
  Build:      CLI 3.0.73
  Old model:  UNREAD — the cron profile's pre-upgrade model was never recorded (honest gap)
  New model:  DeepSeek V4.1 Flash (per the 3.0.73 release note)
  Decision:   KEEP new — bulk lane priced for a flash tier
  Check:      hardest doc task of the week run once on the new default on 2026-10-17; pass
  Cost note:  flash-tier output accepted; per-run cost logged going forward

Rejection artifact (Lane 3, pre-fix, kept as the fleet's reference signature;
representative body, illustrative — pattern matches the documented rejection class):
  HTTP 400
  {"error":{"message":"Unrecognized request argument supplied: max_tokens. 
   This model accepts max_completion_tokens.","type":"invalid_request_error","param":"max_tokens",
   "code":"unknown_argument"}}
  Observed on: 2026-10-16, Cline CLI 3.0.72, model gpt-6-sol, direct OpenAI provider

How this register was produced, in order, so you can reproduce it on your fleet:

1. List every lane — every machine, CI runner and shared VM that runs Cline — and read its build string before anything else.
2. For each lane, read the currently resolved model in provider settings and write it down, even if you plan to change it. An unread old default becomes an honest gap like lane 6, never an invented one; where the release history names the prior default, cite it as lane 5 does.
3. Upgrade to 3.0.73 or 0.0.48, re-read the resolved model, and fill the new-model cell.
4. Decide keep, pin or switch explicitly per lane, and run the scratch task once against the winner, recording usage where the lane is cost-sensitive.
5. Paste any saved pre-fix rejection body into the artifact slot, date the register, and store it with the fleet’s other decisions.

Why lane 6’s gap is recorded rather than papered over: the release note names the new defaults for the touched providers but not every old one. A register that invents precision is worse than one that records a gap to check, because the next operator will trust whatever is written. The correct cell is UNREAD with a decision that survives the missing fact — keep-with-a-check, exactly as lane 6 does — and a cost log that starts today so the next refresh has a baseline.

The worked register also shows the pinning pattern in miniature: three of six lanes are pinned because their behavior is load-bearing (CI prompts, the Azure deployment, the GPT-6 lane), and three ride either the recommended list or a deliberate default with a check attached. That ratio is a reasonable target for a small fleet — enough pinning that no production behavior is inherited, enough flexibility that catalog refreshes still bring you improvements. For the deeper discipline of what earns a model the default slot at all, read the evidence that earns a model the default slot; for pricing two same-list-price models with different agent bill shapes, see the bill-shape test.

Audit the 3.0.73 catalog refresh

The GPT-6 fix is the headline, but the release also refreshes the model catalog: it adds the CommandCode and Reflection providers and changes default models for 302.AI (Gemini 4 Argon), Eden AI and Prime Inference (Muse Spark Open), CoreWeave (Reflection Beam 1.0), NanoGPT, Pioneer (Nemotron 3.5 Super VL) and Scaleway (DeepSeek V4.1 Flash) (CLI 3.0.73 release). Unpinned lanes on those providers now route to a different model than they did last week, with different cost and behavior, and nothing on your screen will announce it.

This is not a one-off wobble. The releases index records the catalog at 6,572 models before the v0.0.93 refresh, then 6,862 after v0.0.93, 6,952 after v0.0.94 and 7,041 after v0.0.95, with the Cline provider default flipping to Gemini 4 Argon in v4.1.25 and CLI 3.0.72, then back to Claude Sonnet 5.5 in 3.0.73 (releases index). A default that moves twice in a week is a default you do not control.

The per-provider decision table for the touched providers — the same structure as the worked register above, one row each, with a worked decision filled in:

Provider	New default (3.0.73)	Worked decision example	Consequence to check
302.AI	Gemini 4 Argon	Keep with a drafting-task check (lane 5 above)	New model’s pricing tier and output shape
Eden AI	Muse Spark Open	Pin old if evals were tuned to it	Re-run your small task eval before trusting
Prime Inference	Muse Spark Open	Keep new only after one scratch task	Different context and reasoning behavior
CoreWeave	Reflection Beam 1.0	Pin old until reviewed	Cost per completed task, not per token
NanoGPT	changed, not named in note	Check in settings, then record either way	Unreviewed model receiving production prompts
Pioneer	Nemotron 3.5 Super VL	Keep new if multimodal helps	Latency and output length habits
Scaleway	DeepSeek V4.1 Flash	Keep new for cheap bulk lanes (lane 6 above)	Flash-tier quality on your hardest tasks

The NanoGPT row is deliberately left as “changed, not named in note” because the release note does not name its new default — a register that invents precision is worse than one that records an honest gap to check in settings. That is the standard to hold: every cell is either read from the lane, stated by the source, or marked unknown.

The register earns its keep in the conversation it prevents. When a teammate asks why outputs changed this week, the answer is a dated row, not a memory of a release note; when a bill moves, the register tells you which lanes changed model before anyone hypothesizes about rate-card updates.

Confirm the Cline provider default and pin what must not drift

The release restores Claude Sonnet 5.5 as the Cline provider default — the model at the top of Cline’s recommended list — for lanes where no model is chosen (CLI 3.0.73 release). If your unpinned Cline-provider lanes were riding Gemini 4 Argon after the 3.0.72-era flip, they just moved back.

1. For each Cline-provider lane, read the resolved model in settings.
2. If it shows Claude Sonnet 5.5 and no model was pinned, that is the documented restoration — expected, not drift.
3. If a lane must stay on a specific model, pin it now; pinned settings are the only ones a catalog refresh cannot move.
4. Add a row to the register for the Cline provider: old default Gemini 4 Argon (3.0.72 era), new default Claude Sonnet 5.5, decision recorded, consequence noted — exactly as lanes 1 and 2 of the worked register show.

Read that back-to-back flip as the lesson it is: an unpinned lane changed model twice inside one week without any action from you, and each change carried different pricing, context handling and output habits. Some lanes genuinely should ride the recommended list — experimental lanes, scratch work, anything where you want the vendor’s current best pick. Production lanes do not belong in that category. Sorting your lanes into those two groups is a one-time exercise, and this week’s flip is the natural moment to do it; the row you write in step four is the receipt that you did.

This is the operating habit the agentic ops thesis keeps arguing: defaults are vendor decisions, and a fleet run on inherited defaults is a fleet nobody is steering. Treat forced routing changes the same way — the model deprecation continuity drill is the sibling procedure for when a vendor removes a model outright rather than redefaulting it.

Rollback and recovery

Every move above has a reverse gear, and the register tells you where it points:

1. A provider regressed after the refresh: pin the previous model from your register’s old-model column; pinning does not require downgrading.
2. The build itself regressed: reinstall the prior CLI or desktop artifact — the desktop release page publishes per-artifact SHA-256 values for exactly this (desktop v0.0.48).
3. An Azure lane misbehaves after reconfiguration: re-verify the three inputs (base URL, deployment id, api-key header) against the Azure reference before blaming the model (Azure OpenAI reference).
4. A GPT-6 lane rejects again: re-check the version string first; the parameter dialect fix is version-gated, and a partially upgraded fleet is the most likely culprit.
5. Keep the dated register and the saved rejection text; both are the diagnostic artifacts that make the next refresh a ten-minute job instead of an afternoon.

Order matters in recovery, and the order is cheap-to-expensive. Pinning a model costs one settings change and no risk; reconfiguring an Azure lane costs a careful re-read of three fields; reinstalling a build costs the most, because it trades a known regression for older known bugs. Run the list top to bottom and stop at the first fix — the failure that survives all four moves is genuinely new, and the artifacts you kept in step five are exactly what a maintainer or colleague will ask to see.

Sources

• Release CLI v3.0.73 · cline/cline · GitHub — primary source; the GPT-6 fix, default restoration and catalog refresh.
• GitHub Releases API record for cli-v3.0.73 — machine-readable release metadata and timestamps.
• Release Desktop v0.0.48 · cline/cline · GitHub — same-day desktop release with signed assets and SHA-256 values.
• Azure OpenAI REST API reference — Microsoft Learn — endpoint paths, deployment ids, api-key header and api-version dialects.
• Releases · cline/cline · GitHub — sibling releases corroborating the rule’s wording, catalog growth and default timeline.