scalemax 0.1.49 → 0.1.50

package/README.md

@@ -151,11 +151,11 @@ For clients without a stable official config file, the installer writes a ScaleM
 
 ### Codex
 
-ScaleMax configures the official Codex custom-provider interface in `~/.codex/config.toml` with `wire_api = "responses"`, and stores the selected key in Codex's private `~/.codex/auth.json`. Detection is semantic: unrelated or ChatGPT-authenticated Codex files are not reported as ScaleMax-configured. Only authenticated Codex/OpenAI-family models are eligible, the generated files are private, and verification performs a minimal `/v1/responses` request before reporting success.
+ScaleMax configures the official Codex custom-provider interface in `~/.codex/config.toml` with `wire_api = "responses"`, and stores the selected key in Codex's private `~/.codex/auth.json`. Detection is semantic: unrelated or ChatGPT-authenticated Codex files are not reported as ScaleMax-configured. Only GPT models from the authenticated catalog are eligible (`gpt-5.6-terra` first, or `auto` on an Auto key); a key with no GPT model is told so and Codex is left unchanged. The generated files are private, and verification performs a minimal `/v1/responses` request before reporting success.
 
 ### Claude Code
 
-ScaleMax updates `~/.claude/settings.json` with `ANTHROPIC_BASE_URL=https://api.scalemax.pro`, gateway model discovery, and a cached `apiKeyHelper` that reads a private `~/.claude/scalemax.key` file. The raw key is not stored in the settings JSON. Because Claude Code's gateway discovery only accepts IDs beginning with `claude` or `anthropic`, catalogs that include Fable or Auto also receive a managed custom picker entry (`ANTHROPIC_CUSTOM_MODEL_OPTION=fable-5` or `auto`, with friendly names and descriptions), making `/model fable-5` and `/model auto` selectable; any prior custom picker values are restored when ScaleMax configuration is removed. The Anthropic base URL intentionally has no `/v1` suffix because Claude Code adds `/v1/messages` itself. The CLI preserves unrelated settings, selects a live main model from the authenticated catalog (preferring `claude-opus-5`), pins authenticated Haiku for lightweight background work when available, and sets `CLAUDE_CODE_DISABLE_THINKING=1` because third-party Anthropic-compatible providers do not support Claude Code's proprietary extended-thinking control envelope. The ScaleMax gateway separately locks native Claude requests to provider-side `low` effort. Fable uses its verified translated controls and supports `low`, `medium`, `high`, and `max`, with `low` as the default. Haiku 4.5 omits the unsupported effort field. It verifies a one-token Messages request and, if verification fails, removes only the ScaleMax-managed changes. Claude Code picker aliases such as `claude-opus-5[1m]` are normalized by the gateway.
+ScaleMax updates `~/.claude/settings.json` with `ANTHROPIC_BASE_URL=https://api.scalemax.pro`, gateway model discovery, and a cached `apiKeyHelper` that reads a private `~/.claude/scalemax.key` file. The raw key is not stored in the settings JSON. Because Claude Code's gateway discovery only accepts IDs beginning with `claude` or `anthropic`, catalogs that include Fable or Auto also receive a managed custom picker entry (`ANTHROPIC_CUSTOM_MODEL_OPTION=fable-5` or `auto`, with friendly names and descriptions), making `/model fable-5` and `/model auto` selectable; any prior custom picker values are restored when ScaleMax configuration is removed. The Anthropic base URL intentionally has no `/v1` suffix because Claude Code adds `/v1/messages` itself. The CLI preserves unrelated settings and selects the main model from the key's own Claude models (Opus 5.5, then Opus 5, Sonnet 5.5, Sonnet 5, older Claude; never the `claude-sonnet-4-6` Claude Desktop alias or another provider's model). The background model (`ANTHROPIC_DEFAULT_HAIKU_MODEL`) is Haiku when the key lists it, otherwise the cheapest Claude it lists, so Claude Code never falls back to a Haiku id the key cannot use. The picker entry prefers an image-capable model; Fable 5.1 is labelled text only. The CLI does not write `CLAUDE_CODE_DISABLE_THINKING`: the ScaleMax gateway strips Claude Code's `thinking` control itself and locks native Claude requests to provider-side `low` effort. Fable uses its verified translated controls and supports `low`, `medium`, `high`, and `max`, with `low` as the default. Haiku 4.5 omits the unsupported effort field. It verifies a one-token Messages request and, if verification fails, removes only the ScaleMax-managed changes. Claude Code picker aliases such as `claude-opus-5[1m]` are normalized by the gateway.
 
 ### OpenCode
 
@@ -171,7 +171,7 @@ ScaleMax creates family-specific Hermes providers in `~/.hermes/config.yaml` and
 
 ### Roo Code (VS Code)
 
-Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Codex, Claude, and tool-capable DeepSeek profiles remain separate. DeepSeek is offered only when authenticated discovery reports `capabilities.tools=true`; otherwise Roo fails closed and points the user to Continue Chat/Edit. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
+Roo Code stores provider profiles and secrets in VS Code extension storage, so ScaleMax does not mutate its private database. Instead, the CLI writes a private `0600` Roo settings-import file at `~/.scalemax/roo-code-import.json` and points the supported `roo-cline.autoImportSettingsPath` VS Code setting at it. Codex, Claude, and tool-capable DeepSeek profiles remain separate; the Codex profile is a GPT model on OpenAI keys and a strong Local model on Local Models keys, never the `claude-sonnet-4-6` alias, and every profile asks for at most 32,768 output tokens. DeepSeek is offered only when authenticated discovery reports `capabilities.tools=true`; otherwise Roo fails closed and points the user to Continue Chat/Edit. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
 
 Roo Code 3.54 (its latest release) looks for ripgrep only in folders newer VS Code releases no longer use, so on recent VS Code versions every task hangs at "API Request…" with "Could not find ripgrep binary". Configuring Roo Code also patches the installed extension's `dist/extension.js` (in the editor's per-user extensions folder, never the VS Code app) so it tries `node_modules.asar.unpacked/@vscode/ripgrep-universal/bin/<platform>-<arch>/` first and then its original folders. The untouched file is kept once as `extension.js.scalemax-orig`. Run `npx scalemax@latest fix-roo` to apply only this fix (VS Code, Insiders, Cursor, Windsurf, VSCodium, Trae, Kiro, and remote servers), `scalemax fix-roo --undo` to restore the original, and reload VS Code afterwards. `scalemax doctor` flags installs that still need it.
 

package/dist/commands/configure.d.ts

@@ -3,6 +3,8 @@ import { ClientId, ConfigureResult } from '../types/client.js';
 export declare function detectAll(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function printDetected(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function clientAllowedForModels(clientId: ClientId, models: ModelInfo[]): boolean;
+/** Why a detected client is not offered for this key, when the reason is worth saying. */
+export declare function clientUnavailableReason(clientId: ClientId, models: ModelInfo[]): string | undefined;
 export declare function rollbackAfterVerificationFailure(result: ConfigureResult, error: unknown): Promise<never>;
 export declare function configureCommand(opts?: {
     all?: boolean;

package/dist/commands/configure.js

@@ -4,9 +4,10 @@ import ora from 'ora';
 import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
-import { validateApiKey, isAnthropicModel, isModelRouteAvailable, AUTO_MODEL_ID, probeWorkingModels, pinClaudeAliasBackend, claudeAliasBackendPinTarget } from '../utils/api.js';
+import { validateApiKey, isAnthropicModel, isChatModel, isModelRouteAvailable, AUTO_MODEL_ID, probeWorkingModels } from '../utils/api.js';
+import { saveModelCheck } from '../utils/modelCheck.js';
 import { homeDir } from '../utils/paths.js';
-import { isExactChatCompletionsModelId } from '../configure/models.js';
+import { CLAUDE_CODE_NEEDS_CLAUDE_MESSAGE, CODEX_NEEDS_GPT_MESSAGE, codexModelIds, defaultModelIdsFor, isExactChatCompletionsModelId, modelIdKey } from '../configure/models.js';
 import { isContinueEligibleModelId } from '../configure/continue.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
@@ -57,10 +58,12 @@ async function maybeLaunchCodex(chosen, successful, baseUrl = SCALEMAX_BASE_URL)
  * for "did Anthropic make this."
  */
 function reachableByClaudeCode(model) {
-    return isAnthropicModel(model) || model.id === AUTO_MODEL_ID;
+    return isAnthropicModel(model) || modelIdKey(model.id) === AUTO_MODEL_ID;
 }
 export function clientAllowedForModels(clientId, models) {
-    models = models.filter(isModelRouteAvailable);
+    // Image, video, embedding and voice rows share the catalog; an image model
+    // owned by `scalemax` must not make Codex look usable on a Claude-only key.
+    models = models.filter(model => isModelRouteAvailable(model) && isChatModel(model));
     if (!models.length)
         return false;
     // These clients use either a native family-specific adapter or the gateway's
@@ -72,8 +75,11 @@ export function clientAllowedForModels(clientId, models) {
         return models.some(model => isContinueEligibleModelId(model.id));
     if (clientId === 'claude')
         return models.some(reachableByClaudeCode);
+    // Codex runs on GPT models only (and on Auto for an Auto key). A Claude id,
+    // the `claude-sonnet-4-6` alias, DeepSeek or a free preview model failed
+    // every Codex request it was configured with.
     if (clientId === 'codex')
-        return models.some(model => !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id));
+        return codexModelIds({ models }).length > 0 || models.some(model => modelIdKey(model.id) === AUTO_MODEL_ID);
     if (clientId === 'hermes' && models.every(model => isExactChatCompletionsModelId(model.id)))
         return models.some(model => model.capabilities?.tools === true);
     // Roo is an agent, not a text-only chat surface. Its task loop depends on
@@ -85,6 +91,16 @@ export function clientAllowedForModels(clientId, models) {
         return true;
     return models.some(model => !isAnthropicModel(model));
 }
+/** Why a detected client is not offered for this key, when the reason is worth saying. */
+export function clientUnavailableReason(clientId, models) {
+    if (clientAllowedForModels(clientId, models))
+        return undefined;
+    if (clientId === 'codex')
+        return CODEX_NEEDS_GPT_MESSAGE.replace('was not set up', 'is not offered');
+    if (clientId === 'claude')
+        return CLAUDE_CODE_NEEDS_CLAUDE_MESSAGE.replace('was not set up', 'is not offered');
+    return undefined;
+}
 export async function rollbackAfterVerificationFailure(result, error) {
     if (!result.changed)
         throw error;
@@ -131,27 +147,17 @@ export async function configureCommand(opts = {}) {
         throw new Error(keyInfo.error || 'ScaleMax returned no models for this API key. No client configuration was changed.');
     const providerScope = keyInfo.key?.provider_scope || 'both';
     const selectedBaseUrl = keyInfo.baseUrl || SCALEMAX_BASE_URL;
-    // LIVE-PROBE the key's models with a small request and keep only the ones
-    // that actually answer, so a client is configured with working models and
-    // defaults to a working one. Bounded (concurrency + total time); if nothing
-    // probes clean we KEEP the entitlement-filtered list rather than fail — a
-    // slow/degraded upstream must not leave the user with zero models.
-    try {
-        const probeSpinner = ora('Checking which models respond').start();
-        const probe = await probeWorkingModels({ apiKey, baseUrl: selectedBaseUrl, models: keyInfo.models, providerScope });
-        if (probe.models.length && !probe.fallback) {
-            keyInfo.models = probe.models;
-            probeSpinner.succeed(`${probe.models.length}/${probe.probedCount} models responded`);
-        }
-        else {
-            probeSpinner.warn(probe.warning || 'No model answered the probe in time; using the full authenticated catalog');
-        }
-    }
-    catch { /* probing is best-effort; never blocks setup */ }
     const availableClients = clients.filter(c => clientAllowedForModels(c.id, keyInfo.models));
     console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Clients are filtered against the authenticated model catalog.`));
     const detections = await printDetected(home);
     const detectedIds = new Set(detections.filter(d => d.installed).map(d => d.id));
+    for (const client of clients) {
+        if (!detectedIds.has(client.id))
+            continue;
+        const reason = clientUnavailableReason(client.id, keyInfo.models);
+        if (reason)
+            console.log(chalk.yellow(`${client.name}: ${reason}`));
+    }
     let chosen;
     if (opts.all)
         chosen = availableClients.filter(c => detectedIds.has(c.id)).map(c => c.id);
@@ -170,6 +176,35 @@ export async function configureCommand(opts = {}) {
         console.log(chalk.yellow('No detected clients to configure.'));
         return;
     }
+    // Check, with one small request each, the models setup is about to write
+    // as defaults for the chosen and detected clients. A default that fails is
+    // skipped (the next pick for that slot is checked instead); every entitled
+    // model stays in the lists written to clients. Bounded in count and time,
+    // and if nothing answers nothing is skipped: a slow upstream or an empty
+    // balance must not leave a client with no model.
+    let avoidModelIds = [];
+    const probeClients = [...new Set([...chosen, ...availableClients.filter(c => detectedIds.has(c.id)).map(c => c.id)])];
+    try {
+        const probeSpinner = ora('Checking the default models (one small request each)').start();
+        const probe = await probeWorkingModels({
+            apiKey,
+            baseUrl: selectedBaseUrl,
+            models: keyInfo.models,
+            providerScope,
+            targets: models => defaultModelIdsFor({ models, providerScope }, probeClients),
+        });
+        if (probe.fallback)
+            probeSpinner.warn(probe.warning || 'No default model answered in time; nothing was skipped.');
+        else if (probe.failedIds.length) {
+            avoidModelIds = probe.failedIds;
+            probeSpinner.warn(`${probe.workingCount}/${probe.probedCount} default models answered; skipped ${probe.failedIds.join(', ')} for now`);
+        }
+        else
+            probeSpinner.succeed(`${probe.workingCount}/${probe.probedCount} default models answered`);
+        // doctor reads this so it expects the same defaults setup wrote.
+        await saveModelCheck(home, apiKey, avoidModelIds).catch(() => undefined);
+    }
+    catch { /* checking is best-effort; never blocks setup */ }
     const successful = new Set();
     const failures = [];
     for (const client of availableClients.filter(c => chosen.includes(c.id))) {
@@ -206,7 +241,7 @@ export async function configureCommand(opts = {}) {
         }
         const spinner = ora(`Configuring ${client.name}`).start();
         try {
-            const ctx = { ...baseCtx, apiKey, baseUrl: selectedBaseUrl, providerScope, models: keyInfo.models, interactive: Boolean(process.stdin.isTTY), allowAppModification };
+            const ctx = { ...baseCtx, apiKey, baseUrl: selectedBaseUrl, providerScope, models: keyInfo.models, avoidModelIds, interactive: Boolean(process.stdin.isTTY), allowAppModification };
             const res = await client.configure(ctx);
             spinner.succeed(`${client.name} ${res.message}`);
             if (res.note)
@@ -233,21 +268,6 @@ export async function configureCommand(opts = {}) {
             failures.push(`${client.name}: ${message}`);
         }
     }
-    // Pin the working default as this key's `claude-sonnet-4-6` backend so Claude
-    // Desktop (which always sends that id) routes to a model this key can serve.
-    // Best-effort: an older gateway without the endpoint, or a scope that already
-    // has a fixed default, is skipped silently. Never fails the run.
-    if (successful.size > 0) {
-        const target = claudeAliasBackendPinTarget(keyInfo.models);
-        if (target) {
-            try {
-                const pin = await pinClaudeAliasBackend({ apiKey, baseUrl: selectedBaseUrl, model: target });
-                if (pin.ok && !pin.skipped)
-                    console.log(chalk.dim(`Claude Desktop's claude-sonnet-4-6 now routes to ${target} on this key.`));
-            }
-            catch { /* endpoint absent or transient; ignore */ }
-        }
-    }
     if (opts.promptLaunch !== false && !opts.all && process.stdin.isTTY)
         await maybeLaunchCodex(chosen, successful, selectedBaseUrl);
     if (failures.length)

package/dist/commands/doctor.js

@@ -3,6 +3,8 @@ import ora from 'ora';
 import { detectAll } from './configure.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey, testStreaming } from '../utils/api.js';
+import { claudeCodeBackgroundModel, fastChatCompletionsModel, preferredChatCompletionsModel } from '../configure/models.js';
+import { loadModelCheck } from '../utils/modelCheck.js';
 import { homeDir } from '../utils/paths.js';
 import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
@@ -30,6 +32,13 @@ export async function doctorCommand(home = homeDir()) {
     let failures = 0;
     const key = await loadApiKey(home);
     let models = [];
+    let baseUrl = SCALEMAX_BASE_URL;
+    // Setup passes the key's scope to every client (Roo writes its profiles by
+    // scope); without it doctor expected a different Roo profile set.
+    let providerScope;
+    // The models setup's live check skipped, so each client is checked against
+    // the same defaults setup wrote (configure/models.ts picks them).
+    const avoidModelIds = key ? await loadModelCheck(home, key) : [];
     if (!key) {
         console.log(`${chalk.red('✗')} API key missing`);
         failures++;
@@ -38,11 +47,24 @@ export async function doctorCommand(home = homeDir()) {
         const s = ora('Checking API key and models').start();
         const res = await validateApiKey(key);
         models = res.models;
+        baseUrl = res.baseUrl || SCALEMAX_BASE_URL;
+        providerScope = res.key?.provider_scope;
         if (res.ok && models.length) {
             s.succeed(`API reachable, key valid, ${models.length} models loaded`);
             console.log(`${chalk.green('✓')} Usage and key metadata accessible through the authenticated API`);
             const st = ora('Checking streaming (small billable request)').start();
-            const stream = await testStreaming(key, models.find(m => m.id === 'fable-5')?.id || models[0]?.id, res.baseUrl);
+            // Stream a cheap chat default: the catalog also lists image, video and
+            // embedding rows (which /chat/completions 404s) and lists the
+            // claude-sonnet-4-6 alias first.
+            const catalog = { models, avoidModelIds };
+            let streamModel;
+            try {
+                streamModel = fastChatCompletionsModel(catalog) || claudeCodeBackgroundModel(catalog) || preferredChatCompletionsModel(catalog);
+            }
+            catch {
+                streamModel = undefined;
+            }
+            const stream = await testStreaming(key, streamModel, baseUrl);
             if (stream.ok)
                 st.succeed('Streaming available');
             else {
@@ -69,8 +91,7 @@ export async function doctorCommand(home = homeDir()) {
         }
         if (client.verify && key && models.length) {
             try {
-                const checked = await validateApiKey(key);
-                const v = await client.verify({ home, platform: process.platform, env: process.env, apiKey: key, baseUrl: checked.baseUrl || SCALEMAX_BASE_URL, models });
+                const v = await client.verify({ home, platform: process.platform, env: process.env, apiKey: key, baseUrl, providerScope, models, avoidModelIds });
                 console.log(`${chalk.green('✓')} ${client.name} ${v.message}`);
             }
             catch (error) {

package/dist/commands/helper-bot.js

@@ -4,15 +4,16 @@ import { createInterface } from 'node:readline/promises';
 import { execa } from 'execa';
 import { clients } from '../clients.js';
 import { helperDocsContext } from './helper-docs.js';
-import { rollbackAfterVerificationFailure } from './configure.js';
-import { createChatCompletion, filterModelsForScope, isAnthropicModel } from '../utils/api.js';
+import { clientAllowedForModels, rollbackAfterVerificationFailure } from './configure.js';
+import { loadModelCheck } from '../utils/modelCheck.js';
+import { createChatCompletion, filterModelsForScope, isAnthropicModel, isChatModel } from '../utils/api.js';
 import { redactApiKey } from '../utils/apiKey.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { homeDir } from '../utils/paths.js';
 import { validateApiKey } from '../utils/api.js';
 import { commandExists } from '../utils/exec.js';
 import { installClaudeGithubTools } from '../configure/claude-tools.js';
-import { isExactChatCompletionsModelId } from '../configure/models.js';
+import { CODEX_NEEDS_GPT_MESSAGE, isExactChatCompletionsModelId, modelIdKey, sameModelId } from '../configure/models.js';
 import { isContinueEligibleModelId } from '../configure/continue.js';
 export const SCALEMAX_HELPER_REFUSAL = `I am the official ScaleMax Helper.
 
@@ -708,21 +709,25 @@ codex
     return undefined;
 }
 export function selectHelperModel(models, requested) {
+    // The helper talks over /chat/completions: never pick an image, video,
+    // embedding or voice row. Ids match in any `[1m]` spelling.
+    const chat = models.filter(isChatModel);
     if (requested) {
-        const exact = models.find(model => model.id.toLowerCase() === requested.toLowerCase());
+        const exact = chat.find(model => model.id.trim().toLowerCase() === requested.trim().toLowerCase())
+            || chat.find(model => sameModelId(model.id, requested));
         if (!exact)
             throw new Error(`Model "${requested}" is not available to this API key. Run \`scalemax models\` to see available models.`);
         return exact.id;
     }
     const preferred = ['gpt-5.6-luna', 'claude-haiku-4-5-20251001', 'fable-5', 'gpt-5.6-terra', 'gpt-5.6-sol'];
     for (const id of preferred) {
-        const match = models.find(model => model.id.toLowerCase() === id);
+        const match = chat.find(model => sameModelId(model.id, id));
         if (match)
             return match.id;
     }
-    if (!models[0])
+    if (!chat[0])
         throw new Error('No ScaleMax model is available to this API key.');
-    return models[0].id;
+    return chat[0].id;
 }
 export async function requestHelperReply(question, history, connection, complete = createChatCompletion) {
     const cleanQuestion = redactHelperSecrets(question.trim(), connection.apiKey);
@@ -832,6 +837,19 @@ function requestedProviderScope(question, target) {
         return 'openai';
     return undefined;
 }
+/**
+ * The GPT/Codex family. The live catalog publishes those models under the
+ * `scalemax` owner (not `openai`, which now labels only embedding rows), so
+ * the owner alone matched no chat model at all.
+ */
+function isOpenAiFamilyModel(model) {
+    const family = String(model.provider || model.owned_by || '').trim().toLowerCase();
+    if (family === 'openai')
+        return true;
+    if (family === 'scalemax')
+        return /^(gpt-|codex-)/i.test(modelIdKey(model.id));
+    return !family && !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id);
+}
 function actionModels(connection, requestedScope) {
     const rawCatalog = connection.modelCatalog?.length
         ? connection.modelCatalog
@@ -840,7 +858,9 @@ function actionModels(connection, requestedScope) {
     // The authenticated catalog already includes reseller and extra-family
     // grants. Validate the primary scope, then narrow only for explicit user
     // intent; never try to reconstruct effective entitlement client-side.
-    const catalog = filterModelsForScope(rawCatalog, entitlement);
+    // Client actions configure chat clients only; image, video, embedding and
+    // voice rows would otherwise be written into them as chat models.
+    const catalog = filterModelsForScope(rawCatalog, entitlement).filter(isChatModel);
     if (!requestedScope || requestedScope === 'reseller' || requestedScope === 'local')
         return catalog;
     const exactModelByScope = {
@@ -851,19 +871,14 @@ function actionModels(connection, requestedScope) {
     };
     const exactModel = exactModelByScope[requestedScope];
     if (exactModel)
-        return catalog.filter(model => model.id.trim().toLowerCase() === exactModel);
+        return catalog.filter(model => modelIdKey(model.id) === exactModel);
     if (requestedScope === 'both') {
-        return catalog.filter(model => isAnthropicModel(model)
-            || String(model.provider || model.owned_by || '').trim().toLowerCase() === 'openai');
+        return catalog.filter(model => isAnthropicModel(model) || isOpenAiFamilyModel(model));
     }
     if (requestedScope === 'anthropic')
         return catalog.filter(isAnthropicModel);
-    if (requestedScope === 'openai') {
-        return catalog.filter(model => {
-            const family = String(model.provider || model.owned_by || '').trim().toLowerCase();
-            return family ? family === 'openai' : !isAnthropicModel(model) && !isExactChatCompletionsModelId(model.id);
-        });
-    }
+    if (requestedScope === 'openai')
+        return catalog.filter(isOpenAiFamilyModel);
     return catalog.filter(model => String(model.provider || model.owned_by || '').trim().toLowerCase() === requestedScope);
 }
 function helperClientAllowedForModels(clientId, models) {
@@ -968,8 +983,8 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
     const models = actionModels(connection, requestedScope);
     if (!models.length)
         throw new Error(`The authenticated key does not expose ${requestedScope === 'anthropic' ? 'Claude' : requestedScope === 'openai' ? 'OpenAI' : requestedScope === 'deepseek-v4-flash' ? 'DeepSeek V4 Flash' : requestedScope === 'glm-5.2' ? 'GLM 5.2' : 'compatible'} models for ${client.name}. No configuration was changed.`);
-    if (client.id === 'codex' && models.every(model => isAnthropicModel(model) || isExactChatCompletionsModelId(model.id)))
-        throw new Error('Codex requires a Responses-capable model, but this key exposes only Claude or Chat-Completions-only models. No configuration was changed.');
+    if (client.id === 'codex' && !clientAllowedForModels('codex', models))
+        throw new Error(`${CODEX_NEEDS_GPT_MESSAGE} No configuration was changed.`);
     if (client.id === 'cursor' && connection.platform !== 'darwin')
         throw new Error(`Automatic Cursor configuration is currently verified on macOS only. ${helperPlatformName(connection.platform)} was not modified.`);
     const ctx = {
@@ -980,6 +995,8 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
         baseUrl: connection.baseUrl,
         providerScope: connection.providerScope || 'both',
         models,
+        // The same defaults setup and doctor use for this key.
+        avoidModelIds: await loadModelCheck(home, connection.apiKey).catch(() => []),
         interactive: false,
         allowAppModification: false
     };

package/dist/configure/claude.js

@@ -6,20 +6,30 @@ import { clientConfigPath } from './paths.js';
 import { writeMergedJsonConfig } from './common.js';
 import { GENERATED_HEADER } from '../constants.js';
 import { redactApiKey } from '../utils/apiKey.js';
-import { anthropicOrigin, fastModel, modelIds, preferredModel, AUTO_MODEL_ID } from './models.js';
+import { anthropicOrigin, claudeCodeBackgroundModel, claudeCodeCustomModelId, claudeCodeMainModel, claudeCodeModelIds, modelAcceptsImages, modelIdKey, AUTO_MODEL_ID, canonicalModelId, sameModelId } from './models.js';
+import { contextSuffix } from '../utils/modelId.js';
 import { removeClientSecret, verifyClientSecret, writeClientSecret } from './client-secret.js';
 const id = 'claude';
 const name = 'Claude Code';
 const discoveryKey = 'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY';
 const fastModelKey = 'ANTHROPIC_DEFAULT_HAIKU_MODEL';
 const helperTtlKey = 'CLAUDE_CODE_API_KEY_HELPER_TTL_MS';
-const disableThinkingKey = 'CLAUDE_CODE_DISABLE_THINKING';
+// Written (as '1') by 0.1.49 and earlier, no longer managed. It is a real
+// Claude Code switch that omits `thinking` from every request, but the
+// gateway already strips `thinking` from Claude Code requests unless the
+// operator turns passthrough on, so writing it only overrode that switch.
+// Reconfiguring removes the value earlier versions wrote.
+const legacyDisableThinkingKey = 'CLAUDE_CODE_DISABLE_THINKING';
 // Claude Code's gateway discovery intentionally ignores model IDs that do not
 // start with `claude` or `anthropic`. Fable and Auto both need managed custom
 // picker entries so their public ScaleMax IDs remain selectable.
 const customModelOptionKey = 'ANTHROPIC_CUSTOM_MODEL_OPTION';
 const customModelOptionNameKey = 'ANTHROPIC_CUSTOM_MODEL_OPTION_NAME';
 const customModelOptionDescriptionKey = 'ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION';
+// Bare public ids. The value written to ANTHROPIC_CUSTOM_MODEL_OPTION carries
+// the catalog's context suffix when it has one (`fable-5[1m]`): Claude Code
+// reads `[1m]` as a 1M context window and strips it before calling the API,
+// while a bare id is budgeted (and auto-compacted) at 200k.
 const fableModelId = 'fable-5';
 const fableModelName = 'Fable 5';
 const fableModelDescription = 'Fable 5 via ScaleMax';
@@ -31,6 +41,8 @@ const fableModelDescription = 'Fable 5 via ScaleMax';
 const fable51ModelId = 'fable-5.1';
 const fable51ModelName = 'Fable 5.1';
 const fable51ModelDescription = 'Fable 5.1 via ScaleMax';
+// Fable 5.1 cannot read images; say so when it is the picker option.
+const fable51TextOnlyDescription = 'Fable 5.1 via ScaleMax (text only, no images)';
 const autoModelName = 'Auto';
 const autoModelDescription = 'Auto via ScaleMax';
 const verificationTimeoutMs = 60_000;
@@ -44,8 +56,7 @@ const managedEnvKeys = [
     customModelOptionDescriptionKey,
     discoveryKey,
     fastModelKey,
-    helperTtlKey,
-    disableThinkingKey
+    helperTtlKey
 ];
 const managedCustomModelValues = new Set([
     fableModelId,
@@ -54,6 +65,7 @@ const managedCustomModelValues = new Set([
     fable51ModelId,
     fable51ModelName,
     fable51ModelDescription,
+    fable51TextOnlyDescription,
     AUTO_MODEL_ID,
     autoModelName,
     autoModelDescription
@@ -68,48 +80,45 @@ function helperCommand(home, platform) {
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
-function hasModelId(ctx, ...ids) {
-    return (ctx.models || []).some(model => ids.includes(String(model.id || '').trim().toLowerCase()));
-}
-function hasFableModel(ctx) {
-    return hasModelId(ctx, fableModelId, 'claude-fable-5');
-}
-function hasAutoModel(ctx) {
-    return modelIds(ctx).some(id => id.trim().toLowerCase() === AUTO_MODEL_ID);
-}
+/**
+ * The one custom picker entry (see claudeCodeCustomModelId): Fable 5 when the
+ * key has it, otherwise an image-capable hidden model, otherwise Fable 5.1
+ * (labelled text only) or Auto. Written in the catalog's spelling, so
+ * `fable-5[1m]` keeps Claude Code's 1M window.
+ */
 function managedCustomModel(ctx) {
-    if (hasFableModel(ctx)) {
-        return {
-            option: fableModelId,
-            name: fableModelName,
-            description: fableModelDescription
-        };
+    const pick = claudeCodeCustomModelId(ctx);
+    if (!pick)
+        return null;
+    const key = modelIdKey(pick);
+    if (key === fableModelId || key === 'claude-fable-5') {
+        return { option: `${fableModelId}${contextSuffix(pick)}`, name: fableModelName, description: fableModelDescription };
     }
-    if (hasModelId(ctx, fable51ModelId)) {
+    if (key === fable51ModelId) {
         return {
-            option: fable51ModelId,
+            option: `${fable51ModelId}${contextSuffix(pick)}`,
             name: fable51ModelName,
-            description: fable51ModelDescription
+            description: modelAcceptsImages(ctx, pick) ? fable51ModelDescription : fable51TextOnlyDescription,
         };
     }
-    if (hasAutoModel(ctx)) {
-        return {
-            option: AUTO_MODEL_ID,
-            name: autoModelName,
-            description: autoModelDescription
-        };
-    }
-    return null;
+    if (key === AUTO_MODEL_ID)
+        return { option: AUTO_MODEL_ID, name: autoModelName, description: autoModelDescription };
+    const label = ctx.models?.find(model => model.id.trim() === pick)?.display_name || canonicalModelId(pick);
+    return { option: pick, name: label, description: `${label} via ScaleMax` };
 }
 function matchesManagedCustomModel(env, customModel) {
-    return env[customModelOptionKey] === customModel.option
+    // `fable-5` written before the catalog advertised `fable-5[1m]` still works,
+    // and so does Fable 5.1's label from before it said "text only".
+    const description = env[customModelOptionDescriptionKey];
+    return sameModelId(env[customModelOptionKey], customModel.option)
         && env[customModelOptionNameKey] === customModel.name
-        && env[customModelOptionDescriptionKey] === customModel.description;
+        && (description === customModel.description
+            || (customModel.description === fable51TextOnlyDescription && description === fable51ModelDescription));
 }
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const model = preferredModel(ctx);
-    const quick = fastModel(ctx);
+    const model = claudeCodeMainModel(ctx);
+    const quick = claudeCodeBackgroundModel(ctx);
     const customModel = managedCustomModel(ctx);
     const baseUrl = anthropicOrigin(ctx.baseUrl);
     const apiKeyHelper = helperCommand(ctx.home, ctx.platform);
@@ -132,9 +141,14 @@ export async function configure(ctx) {
                 ANTHROPIC_BASE_URL: baseUrl,
                 ANTHROPIC_MODEL: model,
                 [discoveryKey]: '1',
-                [helperTtlKey]: '900000',
-                [disableThinkingKey]: '1'
+                [helperTtlKey]: '900000'
             };
+            if (oldMetadata.managedBy === 'ScaleMax CLI' && oldMetadata.disableThinking !== undefined && oldMetadata.disableThinking === nextEnv[legacyDisableThinkingKey]) {
+                if (Object.prototype.hasOwnProperty.call(previousEnv, legacyDisableThinkingKey))
+                    nextEnv[legacyDisableThinkingKey] = previousEnv[legacyDisableThinkingKey];
+                else
+                    delete nextEnv[legacyDisableThinkingKey];
+            }
             if (customModel) {
                 // These are public model IDs, not upstream/provider aliases. Claude
                 // Code's custom option bypasses its `claude*` discovery filter while
@@ -147,10 +161,15 @@ export async function configure(ctx) {
                 // A key can be reconfigured from a Fable/Auto catalog to one that does
                 // not include either model. Remove only the values this CLI previously
                 // managed, restoring any user values captured on the first configure.
+                const written = {
+                    [customModelOptionKey]: oldMetadata.customModelOption,
+                    [customModelOptionNameKey]: oldMetadata.customModelOptionName,
+                    [customModelOptionDescriptionKey]: oldMetadata.customModelOptionDescription,
+                };
                 for (const key of [customModelOptionKey, customModelOptionNameKey, customModelOptionDescriptionKey]) {
                     if (Object.prototype.hasOwnProperty.call(previousEnv, key))
                         nextEnv[key] = previousEnv[key];
-                    else if (managedCustomModelValues.has(String(nextEnv[key] ?? '')))
+                    else if (managedCustomModelValues.has(canonicalModelId(nextEnv[key])) || (written[key] != null && nextEnv[key] === written[key]))
                         delete nextEnv[key];
                 }
             }
@@ -172,7 +191,6 @@ export async function configure(ctx) {
                     gatewayDiscovery: '1',
                     fastModel: quick || null,
                     helperTtl: '900000',
-                    disableThinking: '1',
                     customModelOption: customModel?.option ?? null,
                     customModelOptionName: customModel?.name ?? null,
                     customModelOptionDescription: customModel?.description ?? null,
@@ -208,13 +226,25 @@ export async function verify(ctx) {
     const model = String(env.ANTHROPIC_MODEL || '');
     const customModel = managedCustomModel(ctx);
     const customModelMatches = !customModel || matchesManagedCustomModel(env, customModel);
-    if (!modelIds(ctx).includes(model) || !customModelMatches || env.ANTHROPIC_BASE_URL !== anthropicOrigin(ctx.baseUrl) || settings.apiKeyHelper !== helperCommand(ctx.home, ctx.platform) || env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || env[discoveryKey] !== '1' || env[disableThinkingKey] !== '1') {
-        throw new Error('Claude Code settings do not match the authenticated ScaleMax model catalog.');
+    // Any Claude model the key has is a working main model, in any spelling (a
+    // config written before the catalog advertised `[1m]` still reaches it).
+    // The `claude-sonnet-4-6` alias, a GPT model or a model the key lacks is not:
+    // 0.1.49 wrote the alias, which cannot read images.
+    const usable = claudeCodeModelIds(ctx);
+    if (!usable.some(id => sameModelId(id, model))) {
+        throw new Error(`Claude Code is set to ${model || 'no model'}, which is not a Claude model on this API key. Run \`npx scalemax@latest update\` to switch it to ${claudeCodeMainModel(ctx)}.`);
+    }
+    if (!customModelMatches || env.ANTHROPIC_BASE_URL !== anthropicOrigin(ctx.baseUrl) || settings.apiKeyHelper !== helperCommand(ctx.home, ctx.platform) || env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || env[discoveryKey] !== '1') {
+        throw new Error('Claude Code settings do not match the authenticated ScaleMax model catalog. Run `npx scalemax@latest update`.');
     }
     await verifyClientSecret(secretPath(ctx.home), ctx);
-    const quick = fastModel(ctx);
-    if (quick && env[fastModelKey] !== quick)
-        throw new Error('Claude Code background model does not match the fastest authenticated model.');
+    const quick = claudeCodeBackgroundModel(ctx);
+    const background = env[fastModelKey];
+    // Unset, Claude Code calls its built-in Haiku id for background work, which
+    // a key without Haiku refuses; set, it must be a model this key lists.
+    if (quick ? !usable.some(id => sameModelId(id, background)) : background !== undefined && !usable.some(id => sameModelId(id, background))) {
+        throw new Error(`Claude Code's background model (${background === undefined ? 'not set' : String(background)}) is not a Claude model on this API key. Run \`npx scalemax@latest update\` to set it to ${quick || 'a listed model'}.`);
+    }
     // Verification proves that the authenticated Messages route works; it does
     // not need to warm the user's slower default Opus model.  Prefer Haiku when
     // it is present, while keeping ANTHROPIC_MODEL unchanged for real sessions.
@@ -284,8 +314,9 @@ export async function remove(ctx) {
         restore(fastModelKey);
     if (env[helperTtlKey] === managed.helperTtl)
         restore(helperTtlKey);
-    if (env[disableThinkingKey] === managed.disableThinking)
-        restore(disableThinkingKey);
+    // Only configs written by 0.1.49 and earlier recorded this value.
+    if (managed.disableThinking !== undefined && env[legacyDisableThinkingKey] === managed.disableThinking)
+        restore(legacyDisableThinkingKey);
     if (env[customModelOptionKey] === managed.customModelOption)
         restore(customModelOptionKey);
     if (env[customModelOptionNameKey] === managed.customModelOptionName)

package/dist/configure/cline.js

@@ -14,6 +14,7 @@ const cliVersion = '3.0.47';
 const extensionVersion = '4.0.12';
 const extensionId = 'saoudrizwan.claude-dev';
 const cliProviderId = 'openai-native';
+const CLINE_MAX_OUTPUT_TOKENS = 32_768;
 const legacyProviderId = 'scalemax';
 const extensionCredentialHashKey = 'scalemaxManagedOpenAiApiKeySha256';
 /**
@@ -330,7 +331,8 @@ function positiveInteger(value) {
 function extensionModelInfo(ctx, modelId) {
     const source = (ctx.models || []).find(candidate => candidate.id === modelId);
     return {
-        maxTokens: positiveInteger(source?.max_output_tokens) ?? -1,
+        // Same output budget as Roo: the gateway holds balance for all of it.
+        maxTokens: Math.min(positiveInteger(source?.max_output_tokens) ?? -1, CLINE_MAX_OUTPUT_TOKENS),
         contextWindow: positiveInteger(source?.context_window) ?? 128_000,
         supportsImages: source?.capabilities?.images === true || source?.capabilities?.vision === true,
         supportsPromptCache: source?.capabilities?.prompt_cache === true,