scalemax 0.1.19 → 0.1.20

package/dist/commands/configure.js

@@ -42,7 +42,10 @@ async function maybeLaunchCodex(chosen, successful, baseUrl = SCALEMAX_BASE_URL)
 export function clientAllowedForModels(clientId, models) {
     if (!models.length)
         return false;
-    const crossProtocolClients = new Set(['claude', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    // These clients use either a native family-specific adapter or the gateway's
+    // normalized OpenAI-compatible Chat Completions route, which supports both
+    // authenticated model families. Codex and TRAE remain OpenAI-only.
+    const crossProtocolClients = new Set(['claude', 'cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
     if (crossProtocolClients.has(clientId))
         return true;
     return models.some(model => !isAnthropicModel(model));

package/dist/configure/api-code.js

@@ -5,7 +5,7 @@ const id = 'api-code';
 const name = 'API Code';
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { "environment": { "SCALEMAX_API_KEY": "your ScaleMax API key", "SCALEMAX_BASE_URL": "https://api.scalemax.pro/v1" }, "node": "import OpenAI from 'openai';\nconst client = new OpenAI({ apiKey: process.env.SCALEMAX_API_KEY, baseURL: 'https://api.scalemax.pro/v1' });", "python": "from openai import OpenAI\nclient = OpenAI(api_key='...', base_url='https://api.scalemax.pro/v1')" });
+    const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { environment: { SCALEMAX_API_KEY: 'your ScaleMax API key', SCALEMAX_BASE_URL: ctx.baseUrl }, node: `import OpenAI from 'openai';\nconst client = new OpenAI({ apiKey: process.env.SCALEMAX_API_KEY, baseURL: '${ctx.baseUrl}' });`, python: `from openai import OpenAI\nclient = OpenAI(api_key='...', base_url='${ctx.baseUrl}')` });
     const result = await writeManagedConfig(ctx, id, name, file, content);
     return { ...result, message: 'API code examples written' };
 }

package/dist/configure/cherry-studio.js

@@ -1,11 +1,12 @@
 import { clientConfigPath } from './paths.js';
 import { writeManagedConfig, removeManagedConfig } from './common.js';
 import { jsonConfig } from './templates.js';
+import { preferredChatCompletionsModel } from './models.js';
 const id = 'cherry-studio';
 const name = 'Cherry Studio';
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { "officialSetup": ["Settings > Model Service / Model Providers", "Provider type: OpenAI or OpenAI Compatible", "API host/base URL: https://api.scalemax.pro/v1", "Add ScaleMax model IDs or fetch from /v1/models"], "recommendedModel": "fable-5" });
+    const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { "officialSetup": ["Settings > Model Service / Model Providers", "Provider type: OpenAI or OpenAI Compatible", `API host/base URL: ${ctx.baseUrl}`, `Add only model IDs returned by ${ctx.baseUrl}/models`], "recommendedModel": preferredChatCompletionsModel(ctx) });
     const result = await writeManagedConfig(ctx, id, name, file, content);
     return { ...result, message: 'setup guide written; enter these values in Cherry Studio model provider settings' };
 }

package/dist/configure/models.d.ts

@@ -4,9 +4,18 @@ export declare function anthropicModelIds(ctx: ConfigureContext): string[];
 export declare function openAiModelIds(ctx: ConfigureContext): string[];
 export declare function preferredAnthropicModel(ctx: ConfigureContext): string;
 export declare function preferredOpenAiModel(ctx: ConfigureContext): 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;
+/** 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 anthropicOrigin(baseUrl: string): string;
 export declare function openAiBaseUrl(baseUrl: string): string;

package/dist/configure/models.js

@@ -1,4 +1,4 @@
-import { isAnthropicModel } from '../utils/api.js';
+import { isAnthropicModel, isRetiredModelId } from '../utils/api.js';
 const preferredAnthropic = [
     'claude-opus-4-8',
     'claude-sonnet-5',
@@ -9,23 +9,21 @@ const preferredAnthropic = [
 const preferredOpenAi = [
     'gpt-5.6-terra',
     'gpt-5.6-luna',
-    'gpt-5.6-sol',
     'gpt-5.5',
     'gpt-5.4',
     'gpt-5.4-mini',
     'gpt-5.3-codex',
     'fable-5',
-    'fable-5-ultra',
     'codex-auto-review'
 ];
 export function modelIds(ctx) {
-    return [...new Set((ctx.models || []).map(model => model.id.trim()).filter(Boolean))];
+    return [...new Set((ctx.models || []).map(model => model.id.trim()).filter(id => id && !isRetiredModelId(id)))];
 }
 export function anthropicModelIds(ctx) {
-    return [...new Set((ctx.models || []).filter(isAnthropicModel).map(model => model.id.trim()).filter(Boolean))];
+    return [...new Set((ctx.models || []).filter(isAnthropicModel).map(model => model.id.trim()).filter(id => id && !isRetiredModelId(id)))];
 }
 export function openAiModelIds(ctx) {
-    return [...new Set((ctx.models || []).filter(model => !isAnthropicModel(model)).map(model => model.id.trim()).filter(Boolean))];
+    return [...new Set((ctx.models || []).filter(model => !isAnthropicModel(model)).map(model => model.id.trim()).filter(id => id && !isRetiredModelId(id)))];
 }
 function preferredFrom(ids, candidates, family) {
     for (const candidate of candidates)
@@ -41,6 +39,15 @@ export function preferredAnthropicModel(ctx) {
 export function preferredOpenAiModel(ctx) {
     return preferredFrom(openAiModelIds(ctx), preferredOpenAi, 'Codex/OpenAI');
 }
+/**
+ * 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 function preferredChatCompletionsModel(ctx) {
+    return openAiModelIds(ctx).length ? preferredOpenAiModel(ctx) : preferredAnthropicModel(ctx);
+}
 export function preferredModel(ctx) {
     const ids = modelIds(ctx);
     for (const candidate of [...preferredAnthropic, ...preferredOpenAi])
@@ -60,6 +67,10 @@ export function fastOpenAiModel(ctx) {
     return ids.find(id => id === 'gpt-5.4-mini')
         || ids.find(id => /(^|[-.])(mini|nano)([-.]|$)/i.test(id));
 }
+/** The lightweight model for an OpenAI-compatible chat client, if one exists. */
+export function fastChatCompletionsModel(ctx) {
+    return fastOpenAiModel(ctx) || fastModel(ctx);
+}
 export function modelName(ctx, id) {
     const model = (ctx.models || []).find(candidate => candidate.id === id);
     if (model?.display_name)

package/dist/configure/opencode.js

@@ -3,7 +3,7 @@ import fs from 'fs-extra';
 import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
 import { writeMergedJsonConfig } from './common.js';
-import { fastOpenAiModel, modelName, openAiBaseUrl, openAiModelIds, preferredOpenAiModel } from './models.js';
+import { fastChatCompletionsModel, modelIds, modelName, openAiBaseUrl, preferredChatCompletionsModel } from './models.js';
 import { removeClientSecret, rollbackClientSecret, verifyClientSecret, writeClientSecret } from './client-secret.js';
 const id = 'opencode';
 const name = 'OpenCode';
@@ -13,7 +13,7 @@ function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
 function providerConfig(ctx) {
-    const models = Object.fromEntries(openAiModelIds(ctx).map(modelId => {
+    const models = Object.fromEntries(modelIds(ctx).map(modelId => {
         const metadata = (ctx.models || []).find(model => model.id === modelId);
         return [modelId, {
                 name: modelName(ctx, modelId),
@@ -32,8 +32,8 @@ function providerConfig(ctx) {
 }
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const selected = `scalemax/${preferredOpenAiModel(ctx)}`;
-    const quick = fastOpenAiModel(ctx);
+    const selected = `scalemax/${preferredChatCompletionsModel(ctx)}`;
+    const quick = fastChatCompletionsModel(ctx);
     const secret = await writeClientSecret(secretPath(ctx.home), ctx);
     let result;
     try {
@@ -55,7 +55,7 @@ export async function configure(ctx) {
         await rollbackClientSecret(secretPath(ctx.home), ctx, secret);
         throw error;
     }
-    return { ...result, changed: result.changed || secret.changed, message: `${result.message}; file-backed credential${quick ? `; ${quick} handles lightweight work` : ''}` };
+    return { ...result, changed: result.changed || secret.changed, message: `${result.message}; file-backed credential and ${modelIds(ctx).length} authenticated chat model(s)${quick ? `; ${quick} handles lightweight work` : ''}` };
 }
 export async function verify(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
@@ -66,11 +66,11 @@ export async function verify(ctx) {
     }
     await verifyClientSecret(secretPath(ctx.home), ctx);
     const configured = Object.keys(asRecord(provider.models));
-    const expected = openAiModelIds(ctx);
+    const expected = modelIds(ctx);
     const missing = expected.filter(model => !configured.includes(model));
     const unexpected = configured.filter(model => !expected.includes(model));
     if (missing.length || unexpected.length)
-        throw new Error(`OpenCode model catalog is not restricted to the ${expected.length} authenticated Codex/OpenAI model(s).`);
+        throw new Error(`OpenCode model catalog is not restricted to the ${expected.length} authenticated chat model(s).`);
     return { id, name, changed: false, path: file, message: `verified ${configured.length} ScaleMax models` };
 }
 export async function remove(ctx) {

package/dist/configure/roo-code.js

@@ -3,14 +3,24 @@ import fs from 'fs-extra';
 import JSON5 from 'json5';
 import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
-import { openAiBaseUrl, openAiModelIds, preferredOpenAiModel } from './models.js';
+import { openAiBaseUrl, preferredChatCompletionsModel } from './models.js';
+import { isAnthropicModel } from '../utils/api.js';
 const id = 'roo-code';
 const name = 'Roo Code (VS Code)';
 const importSetting = 'roo-cline.autoImportSettingsPath';
 const importSettingValue = '~/.scalemax/roo-code-import.json';
-const profileName = 'ScaleMax Codex';
-const profileId = 'scalemax-codex';
+const codexProfileName = 'ScaleMax Codex';
+const claudeProfileName = 'ScaleMax Claude';
+const codexProfileId = 'scalemax-codex';
+const claudeProfileId = 'scalemax-claude';
 function importPath(home) { return path.join(home, '.scalemax', 'roo-code-import.json'); }
+function profileFor(ctx) {
+    const model = preferredChatCompletionsModel(ctx);
+    const metadata = (ctx.models || []).find(candidate => candidate.id === model) || { id: model };
+    return isAnthropicModel(metadata)
+        ? { name: claudeProfileName, id: claudeProfileId, model }
+        : { name: codexProfileName, id: codexProfileId, model };
+}
 function parseSettings(text, file) {
     if (!text)
         return {};
@@ -25,17 +35,17 @@ function parseSettings(text, file) {
     }
 }
 function handoff(ctx) {
-    const selected = preferredOpenAiModel(ctx);
+    const profile = profileFor(ctx);
     return JSON.stringify({
         providerProfiles: {
-            currentApiConfigName: profileName,
+            currentApiConfigName: profile.name,
             apiConfigs: {
-                [profileName]: {
-                    id: profileId,
+                [profile.name]: {
+                    id: profile.id,
                     apiProvider: 'openai',
                     openAiBaseUrl: openAiBaseUrl(ctx.baseUrl),
                     openAiApiKey: ctx.apiKey,
-                    openAiModelId: selected,
+                    openAiModelId: profile.model,
                     openAiStreamingEnabled: true,
                     includeMaxTokens: true
                 }
@@ -46,8 +56,6 @@ function handoff(ctx) {
     }, null, 2) + '\n';
 }
 export async function configure(ctx) {
-    if (!openAiModelIds(ctx).length)
-        throw new Error('Roo Code OpenAI Compatible setup requires at least one Codex/OpenAI model.');
     const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
     const profileFile = importPath(ctx.home);
     const originalSettings = await fs.readFile(settingsFile, 'utf8').catch(() => '');
@@ -82,10 +90,11 @@ export async function verify(ctx) {
     const profileFile = importPath(ctx.home);
     const settings = parseSettings(await fs.readFile(settingsFile, 'utf8'), settingsFile);
     const profile = await fs.readJson(profileFile).catch(() => undefined);
-    const config = profile?.providerProfiles?.apiConfigs?.[profileName];
-    if (settings[importSetting] !== importSettingValue || profile?.providerProfiles?.currentApiConfigName !== profileName
-        || config?.id !== profileId || config?.apiProvider !== 'openai' || config?.openAiBaseUrl !== openAiBaseUrl(ctx.baseUrl)
-        || config?.openAiApiKey !== ctx.apiKey || config?.openAiModelId !== preferredOpenAiModel(ctx) || config?.openAiStreamingEnabled !== true
+    const expected = profileFor(ctx);
+    const config = profile?.providerProfiles?.apiConfigs?.[expected.name];
+    if (settings[importSetting] !== importSettingValue || profile?.providerProfiles?.currentApiConfigName !== expected.name
+        || config?.id !== expected.id || config?.apiProvider !== 'openai' || config?.openAiBaseUrl !== openAiBaseUrl(ctx.baseUrl)
+        || config?.openAiApiKey !== ctx.apiKey || config?.openAiModelId !== expected.model || config?.openAiStreamingEnabled !== true
         || config?.includeMaxTokens !== true) {
         throw new Error('Roo Code auto-import handoff is incomplete.');
     }
@@ -109,7 +118,12 @@ export async function remove(ctx) {
     }
     if (await fs.pathExists(profileFile)) {
         const profile = await fs.readJson(profileFile).catch(() => undefined);
-        if (profile?.providerProfiles?.apiConfigs?.[profileName]?.id === profileId) {
+        const configs = profile?.providerProfiles?.apiConfigs;
+        const managed = [
+            configs?.[codexProfileName]?.id === codexProfileId,
+            configs?.[claudeProfileName]?.id === claudeProfileId
+        ].some(Boolean);
+        if (managed) {
             await backupFile(profileFile, ctx.home);
             await fs.remove(profileFile);
             changed = true;

package/dist/configure/trae-solo.js

@@ -5,7 +5,7 @@ const id = 'trae-solo';
 const name = 'TRAE SOLO';
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { "officialSetup": ["Settings > Models > Add Model", "API format: OpenAI Chat Completions", "Request URL: https://api.scalemax.pro/v1/chat/completions or base URL https://api.scalemax.pro/v1", "Model ID: fable-5 or another ScaleMax model"], "recommendedModel": "fable-5" });
+    const content = jsonConfig(name, '$SCALEMAX_API_KEY', ctx.baseUrl, { "officialSetup": ["Settings > Models > Add Model", "API format: OpenAI Chat Completions", `Request URL: ${ctx.baseUrl}/chat/completions or base URL ${ctx.baseUrl}`, "Use only a model ID returned by the authenticated catalog"], "recommendedModel": "fable-5" });
     const result = await writeManagedConfig(ctx, id, name, file, content);
     return { ...result, message: 'setup guide written; enter these values in TRAE SOLO custom model settings' };
 }

package/dist/utils/api.d.ts

@@ -22,6 +22,8 @@ export interface ApiValidation {
     error?: string;
     surfaceMismatch?: boolean;
 }
+export declare const RETIRED_MODEL_IDS: Set<string>;
+export declare function isRetiredModelId(id: string): boolean;
 export declare function isAnthropicModel(model: ModelInfo): boolean;
 export declare function filterModelsForScope(models: ModelInfo[], scope: ProviderScope): ModelInfo[];
 export declare function validateApiKey(apiKey: string): Promise<ApiValidation>;

package/dist/utils/api.js

@@ -1,5 +1,12 @@
 import { SCALEMAX_BASE_URL, SCALEMAX_TOKEN_BASE_URL } from '../constants.js';
 import { redactApiKey, sanitizeApiKey } from './apiKey.js';
+// These aliases are intentionally unavailable because their upstream routes
+// were retired after repeated 5xx responses. Keep a stale catalog response
+// from selecting or advertising a model that cannot complete requests.
+export const RETIRED_MODEL_IDS = new Set(['gpt-5.6-sol', 'fable-5-ultra']);
+export function isRetiredModelId(id) {
+    return RETIRED_MODEL_IDS.has(id.trim());
+}
 export function isAnthropicModel(model) {
     const provider = String(model.provider || model.owned_by || '').trim().toLowerCase();
     if (provider)
@@ -7,9 +14,8 @@ export function isAnthropicModel(model) {
     return model.id.startsWith('claude-') && !model.id.startsWith('claude-fable-');
 }
 export function filterModelsForScope(models, scope) {
-    if (scope === 'both')
-        return models;
-    return models.filter(model => scope === 'anthropic' ? isAnthropicModel(model) : !isAnthropicModel(model));
+    return models.filter(model => !isRetiredModelId(model.id)
+        && (scope === 'both' || (scope === 'anthropic' ? isAnthropicModel(model) : !isAnthropicModel(model))));
 }
 async function friendlyError(res) {
     let body = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalemax",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {