scalemax 0.1.49 → 0.1.50

package/dist/configure/codex.js

@@ -6,7 +6,7 @@ import { codexAuthPath, codexConfigPath } from './paths.js';
 import { atomicWrite, backupFile, captureFileSnapshots, listBackups, restoreFileSnapshots, snapshotRollback } from '../utils/fs.js';
 import { GENERATED_HEADER } from '../constants.js';
 import { commandExists } from '../utils/exec.js';
-import { AUTO_MODEL_ID, preferredOpenAiResponsesModel } from './models.js';
+import { AUTO_MODEL_ID, codexModel, codexModelIds, sameModelId } from './models.js';
 const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
@@ -40,7 +40,17 @@ function selectedModel(ctx) {
         // Auto key cannot call and would 403 every request.
         return ctx.providerScope === 'auto-api' ? AUTO_MODEL_ID : fallbackModel;
     }
-    return preferredOpenAiResponsesModel(ctx);
+    // GPT only (or Auto on an Auto key); throws a plain explanation otherwise.
+    return codexModel(ctx);
+}
+/** A model Codex can run on with this key: any of its GPT models, or Auto. */
+function codexCanUse(ctx, configured) {
+    if (typeof configured !== 'string' || !configured.trim())
+        return false;
+    if (!ctx.models)
+        return configured === selectedModel(ctx);
+    return codexModelIds(ctx).some(id => sameModelId(id, configured))
+        || (sameModelId(configured, AUTO_MODEL_ID) && sameModelId(selectedModel(ctx), AUTO_MODEL_ID));
 }
 function scalemaxCodexBlock(baseUrl, model = fallbackModel, authHash, keyHash) {
     const authMarker = authHash ? `${managedAuthHashPrefix}${authHash}\n` : '';
@@ -329,8 +339,11 @@ export async function verifyCodexConfiguration(ctx) {
         errors.push(`${authPath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
     }
     const toml = parseSimpleTomlForCodex(configText);
-    if (toml.model !== model)
-        errors.push(`Codex model mismatch: expected ${model}`);
+    // Any GPT model this key has is a working choice (the user may pick another
+    // one); a Claude id, the claude-sonnet-4-6 alias or a model the key lacks is
+    // not. 0.1.49 wrote the alias, and every Codex request on it failed.
+    if (!codexCanUse(ctx, toml.model))
+        errors.push(`Codex is set to ${toml.model ? `"${toml.model}"` : 'no model'}, which is not a GPT model on this API key. Run \`npx scalemax@latest update\` to switch it to ${model}.`);
     if (toml.model_provider !== provider)
         errors.push(`Codex model_provider mismatch: expected ${provider}`);
     if (toml.model_reasoning_effort !== reasoningEffort)
@@ -382,15 +395,17 @@ export async function verifyCodexConfiguration(ctx) {
     else {
         warnings.push('Codex executable was not found on PATH, so launch verification was skipped.');
     }
+    // Check the model Codex will actually call: the configured one when it is valid.
+    const liveModel = codexCanUse(ctx, toml.model) ? toml.model : model;
     try {
         const res = await fetch(`${ctx.baseUrl}/responses`, {
             method: 'POST',
             headers: { Authorization: `Bearer ${ctx.apiKey}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ model, input: 'Reply K', stream: false, max_output_tokens: 8 }),
+            body: JSON.stringify({ model: liveModel, input: 'Reply K', stream: false, max_output_tokens: 8 }),
             signal: AbortSignal.timeout(15000)
         });
         if (res.status === 404)
-            warnings.push(`ScaleMax /v1/responses returned HTTP 404 for model "${model}". Codex requires the Responses API to complete requests; verify the base URL is correct and that this API key is entitled to that model.`);
+            warnings.push(`ScaleMax /v1/responses returned HTTP 404 for model "${liveModel}". Codex requires the Responses API to complete requests; verify the base URL is correct and that this API key is entitled to that model.`);
         else if (res.status === 401 || res.status === 403)
             errors.push(`ScaleMax rejected the API key on /v1/responses with HTTP ${res.status}`);
         else if (!res.ok)

package/dist/configure/continue.js

@@ -6,7 +6,7 @@ import { atomicWrite, backupFile, captureFileSnapshots, restoreFileSnapshots, sn
 import { commandExists } from '../utils/exec.js';
 import { clientConfigPath } from './paths.js';
 import { isScaleMaxApiUrl } from './common.js';
-import { isExactChatCompletionsModelId, modelName as displayModelName, AUTO_MODEL_ID } from './models.js';
+import { isExactChatCompletionsModelId, modelIdKey, modelName as displayModelName, AUTO_MODEL_ID } from './models.js';
 /**
  * Which single-model keys Continue's automatic setup can configure.
  *
@@ -24,7 +24,7 @@ import { isExactChatCompletionsModelId, modelName as displayModelName, AUTO_MODE
  * -- live-verified, 2026-08-08).
  */
 export function isContinueEligibleModelId(id) {
-    return isExactChatCompletionsModelId(id) || id.trim().toLowerCase() === AUTO_MODEL_ID;
+    return isExactChatCompletionsModelId(id) || modelIdKey(id) === AUTO_MODEL_ID;
 }
 const id = 'continue';
 const name = 'Continue (VS Code)';

package/dist/configure/cursor.js

@@ -5,8 +5,11 @@ import { scaleMaxDir, timestamp } from '../utils/paths.js';
 import { captureFileSnapshots, readJson, restoreFileSnapshots, writeJsonAtomic } from '../utils/fs.js';
 import { resolveCursorAppPath, inspectCursorBundles, patchCursorBundles, restoreCursorBundles } from './cursor-bundle.js';
 import { configureCursorState, restoreCursorState } from './cursor-state.js';
+import { isChatModel } from '../utils/api.js';
 const id = 'cursor', name = 'Cursor';
 function manifestPath(ctx) { return path.join(scaleMaxDir(ctx.home, ctx.platform, ctx.env), 'cursor', 'manifest.json'); }
+// Cursor's picker is chat-only: image, video, embedding and voice rows stay out.
+function chatModels(ctx) { return (ctx.models || []).filter(model => isChatModel(model)); }
 async function cursorVersion(appPath) { try {
     return (await fs.readJson(path.join(appPath, 'Contents', 'Resources', 'app', 'package.json')))?.version;
 }
@@ -48,7 +51,7 @@ export async function configure(ctx) {
         patchResult = await patchCursorBundles(appPath, ctx.home, ctx.platform, ctx.env);
         const backupRoot = patchResult.backupRoot || stateBackupRoot;
         await fs.ensureDir(backupRoot, { mode: 0o700 });
-        state = await configureCursorState(ctx.home, ctx.platform, ctx.env, ctx.apiKey, ctx.baseUrl, ctx.models || [], backupRoot);
+        state = await configureCursorState(ctx.home, ctx.platform, ctx.env, ctx.apiKey, ctx.baseUrl, chatModels(ctx), backupRoot);
         const manifestState = prior?.state ? { ...state, originalState: prior.state.originalState, originalSecret: prior.state.originalSecret } : state;
         const bundles = patchResult.managed ? patchResult.records : (prior?.bundleManaged ? prior.bundles : patchResult.records);
         const manifest = { schemaVersion: 1, createdAt: new Date().toISOString(), appPath, version: await cursorVersion(appPath), bundleManaged: Boolean(patchResult.managed || prior?.bundleManaged), bundles, state: manifestState };
@@ -104,7 +107,7 @@ export async function verify(ctx) {
     const manifest = await readJson(manifestPath(ctx), undefined), appPath = await resolveCursorAppPath(ctx.platform, ctx.env, ctx.home, manifest?.appPath), inspection = await inspectCursorBundles(appPath);
     if (inspection.status !== 'patched' || !manifest?.state?.modelIds?.length)
         throw new Error('Cursor local BYOK patch or protected model state is incomplete.');
-    const live = new Set((ctx.models || []).map(m => m.id)), configured = new Set(manifest.state.modelIds), missing = [...live].filter(x => !configured.has(x));
+    const live = new Set(chatModels(ctx).map(m => m.id)), configured = new Set(manifest.state.modelIds), missing = [...live].filter(x => !configured.has(x));
     if (missing.length)
         throw new Error(`Cursor is missing ${missing.length} live ScaleMax model(s). Rerun update.`);
     return { id, name, changed: false, path: manifestPath(ctx), message: `verified local BYOK patch and ${configured.size} configured model IDs` };

package/dist/configure/hermes.js

@@ -4,7 +4,7 @@ import { parseDocument } from 'yaml';
 import { atomicWrite, backupFile, captureFileSnapshots, restoreFileSnapshots, snapshotRollback } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
 import { isScaleMaxApiUrl, isScaleMaxManagedText } from './common.js';
-import { anthropicModelIds, anthropicOrigin, deepSeekChatModelIds, modelSupportsTools, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredOpenAiResponsesModel } from './models.js';
+import { anthropicModelIds, anthropicOrigin, deepSeekChatModelIds, modelIdKey, modelSupportsTools, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredOpenAiResponsesModel } from './models.js';
 const id = 'hermes';
 const name = 'Hermes';
 const envKey = 'SCALEMAX_HERMES_API_KEY';
@@ -15,12 +15,12 @@ const deepSeekProviderName = 'scalemax-deepseek';
 const glmProviderName = 'scalemax-glm-5-2';
 const claudeProviderName = 'scalemax-claude';
 function exactChatProviderName(ids) {
-    return ids.length > 0 && ids.every(id => id.trim().toLowerCase() === 'glm-5.2')
+    return ids.length > 0 && ids.every(id => modelIdKey(id) === 'glm-5.2')
         ? glmProviderName
         : deepSeekProviderName;
 }
 function exactChatLabel(ids) {
-    return ids.length > 0 && ids.every(id => id.trim().toLowerCase() === 'glm-5.2')
+    return ids.length > 0 && ids.every(id => modelIdKey(id) === 'glm-5.2')
         ? 'GLM 5.2'
         : 'DeepSeek';
 }

package/dist/configure/models.d.ts

@@ -1,4 +1,11 @@
-import { ConfigureContext } from '../types/client.js';
+import type { ClientId, ConfigureContext } from '../types/client.js';
+import { type ModelInfo } from '../utils/api.js';
+export { canonicalModelId, modelIdKey, sameModelId } from '../utils/modelId.js';
+/**
+ * Model selection reads only the authenticated catalog, plus the ids the
+ * setup probe saw fail (`avoidModelIds`), which defaults skip.
+ */
+type CatalogContext = Pick<ConfigureContext, 'models' | 'avoidModelIds'>;
 export declare const DEEPSEEK_V4_FLASH_MODEL_ID = "deepseek-v4-flash";
 export declare const GLM_5_2_MODEL_ID = "glm-5.2";
 export declare const DEEPSEEK_V4_PRO_MODEL_ID = "deepseek-v4-pro";
@@ -21,35 +28,90 @@ export interface AuthenticatedChatCapabilities {
     streamingUsage: boolean;
     reasoningReplay: boolean;
 }
-export declare function authenticatedChatCapabilities(ctx: ConfigureContext, id: string): AuthenticatedChatCapabilities;
+/**
+ * The catalog row for `id`: the exact spelling first, then the same model
+ * under another context suffix (`claude-opus-5` finds `claude-opus-5[1m]`).
+ */
+export declare function catalogModel(ctx: CatalogContext, id: string): ModelInfo | undefined;
+export declare function authenticatedChatCapabilities(ctx: CatalogContext, id: string): AuthenticatedChatCapabilities;
 /** Exact model aliases that are Chat-Completions-only, never Responses API. */
 export declare function isExactChatCompletionsModelId(id: string): boolean;
 /** Backward-compatible internal name for legacy client configuration code. */
 export declare const isDeepSeekChatModelId: typeof isExactChatCompletionsModelId;
 /** Trust only the authenticated gateway catalog for endpoint capabilities. */
-export declare function modelSupportsTools(ctx: ConfigureContext, id: string): boolean;
-export declare function modelIds(ctx: ConfigureContext): string[];
-export declare function anthropicModelIds(ctx: ConfigureContext): string[];
-export declare function openAiModelIds(ctx: ConfigureContext): string[];
+export declare function modelSupportsTools(ctx: CatalogContext, id: string): boolean;
+export declare function modelIds(ctx: CatalogContext): string[];
+export declare function anthropicModelIds(ctx: CatalogContext): string[];
+export declare function openAiModelIds(ctx: CatalogContext): string[];
 /** Models that must stay on the OpenAI-compatible Chat Completions route. */
-export declare function deepSeekChatModelIds(ctx: ConfigureContext): string[];
+export declare function deepSeekChatModelIds(ctx: CatalogContext): string[];
 /** Non-Anthropic models that may remain on existing Responses-based clients. */
-export declare function openAiResponsesModelIds(ctx: ConfigureContext): string[];
-export declare function preferredAnthropicModel(ctx: ConfigureContext): string;
-export declare function preferredOpenAiModel(ctx: ConfigureContext): string;
-export declare function preferredOpenAiResponsesModel(ctx: ConfigureContext): string;
+export declare function openAiResponsesModelIds(ctx: CatalogContext): string[];
+/** GPT and Codex-family ids (not gpt-image-* or gpt-oss-*). */
+export declare function isGptModelId(id: string): boolean;
+/** The catalog says the model accepts image input. Missing metadata fails closed. */
+export declare function modelAcceptsImages(ctx: CatalogContext, id: string): boolean;
+/**
+ * The best Claude this key has, for Claude Code and every client's Claude
+ * profile: Opus 5.5, Opus 5, Sonnet 5.5, Sonnet 5, then older Claude, then
+ * any other `claude-*` row, then an image-capable Anthropic row (Fable 5)
+ * before a text-only one. Never a model from another provider.
+ */
+export declare function preferredAnthropicModel(ctx: CatalogContext): string;
+/** Every catalog id Claude Code can be pointed at: Claude rows, or Auto. */
+export declare function claudeCodeModelIds(ctx: CatalogContext): string[];
+export declare const CLAUDE_CODE_NEEDS_CLAUDE_MESSAGE = "This API key has no Claude model, so Claude Code was not set up. Claude Code needs a key on the Claude or OpenAI + Claude plan: https://scalemax.pro/pricing";
+/** Claude Code's ANTHROPIC_MODEL. */
+export declare function claudeCodeMainModel(ctx: CatalogContext): string;
+/**
+ * Claude Code's background model (ANTHROPIC_DEFAULT_HAIKU_MODEL): Haiku when
+ * the key lists it, else the cheapest Claude the key lists, else nothing.
+ * Leaving it unset on a key without Haiku made Claude Code call its built-in
+ * Haiku id, which the key then refused on every background request.
+ */
+export declare function claudeCodeBackgroundModel(ctx: CatalogContext): string | undefined;
+/**
+ * Claude Code's picker hides gateway ids that do not start with `claude` or
+ * `anthropic`, so ONE custom option exposes Fable or Auto. Fable 5 keeps the
+ * slot whenever the key has it (re-running setup never moves a user onto a
+ * different model and price); among the rest an image-capable model wins, so
+ * a pasted screenshot does not fail on a text-only default.
+ */
+export declare function claudeCodeCustomModelId(ctx: CatalogContext): string | undefined;
+/** GPT models Codex can run on (Responses API). */
+export declare function codexModelIds(ctx: CatalogContext): string[];
+export declare const CODEX_NEEDS_GPT_MESSAGE = "This API key has no GPT model, so Codex was not set up. Codex runs on GPT models only: use a key on the OpenAI or OpenAI + Claude plan: https://scalemax.pro/pricing";
+/**
+ * Codex's model: a GPT model the key has (gpt-5.6-terra first), or `auto` on
+ * an Auto key. Never a Claude id, the `claude-sonnet-4-6` alias, DeepSeek or
+ * another family's model: Codex's Responses requests fail on those.
+ */
+export declare function codexModel(ctx: CatalogContext): string;
+/** Non-Claude default for OpenAI-compatible clients: GPT, then Local, then other families. */
+export declare function preferredOpenAiModel(ctx: CatalogContext): string;
+export declare function preferredOpenAiResponsesModel(ctx: CatalogContext): string;
 /**
  * OpenAI-compatible chat clients can use the gateway's normalized chat route
- * for either family. Keep an OpenAI model as the default when one is present
- * so existing mixed-catalog configurations do not unexpectedly switch model
- * families; a Claude-only catalog naturally selects its preferred Claude model.
- */
-export declare function preferredChatCompletionsModel(ctx: ConfigureContext): string;
-export declare function preferredModel(ctx: ConfigureContext): string;
-export declare function fastModel(ctx: ConfigureContext): string | undefined;
-export declare function fastOpenAiModel(ctx: ConfigureContext): string | undefined;
+ * for either family. A GPT model stays the default when the key has one, so
+ * mixed-catalog configurations do not switch model families; a Claude key
+ * gets its best Claude (its free and alias rows are not a reason to leave
+ * Claude); Local, Gemini, Grok and Qwen keys get their own flagship.
+ */
+export declare function preferredChatCompletionsModel(ctx: CatalogContext): string;
+export declare function fastModel(ctx: CatalogContext): string | undefined;
+export declare function fastOpenAiModel(ctx: CatalogContext): string | undefined;
 /** The lightweight model for an OpenAI-compatible chat client, if one exists. */
-export declare function fastChatCompletionsModel(ctx: ConfigureContext): string | undefined;
-export declare function modelName(ctx: ConfigureContext, id: string): string;
+export declare function fastChatCompletionsModel(ctx: CatalogContext): string | undefined;
+/**
+ * The model ids setup would write as defaults for these clients, most
+ * important first: Claude Code's main, background and picker models, Codex's
+ * model, then the chat and agent clients' defaults. Lists (Cursor, OpenCode's
+ * model table) are not defaults. The setup probe checks exactly these and
+ * asks again after a failure, instead of the first rows of the catalog.
+ */
+export declare function defaultModelIdsFor(ctx: CatalogContext & Pick<ConfigureContext, 'providerScope'>, clientIds: readonly ClientId[]): string[];
+export declare function modelName(ctx: CatalogContext, id: string): string;
+/** Opus 5 / 5.5 publish a 128k output cap that OpenCode and OpenClaw honour. */
+export declare function hasLargeOutputCap(id: string): boolean;
 export declare function anthropicOrigin(baseUrl: string): string;
 export declare function openAiBaseUrl(baseUrl: string): string;