scalemax 0.1.18 → 0.1.20

package/README.md

@@ -104,6 +104,7 @@ SCALEMAX_API_KEY=sm_live_xxx scalemax models
 
 - Codex
 - Cursor
+- Roo Code (VS Code)
 - TRAE SOLO
 - Claude Code
 - OpenCode
@@ -114,21 +115,29 @@ SCALEMAX_API_KEY=sm_live_xxx scalemax models
 
 For clients without a stable official config file, the installer writes a ScaleMax setup guide under `~/.scalemax/` instead of modifying private app storage.
 
+### 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.
+
 ### 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. 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-4-8`), 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. 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-4-8[1m]` are normalized by the gateway.
 
 ### OpenCode
 
-ScaleMax merges a named `scalemax` provider into `~/.config/opencode/opencode.json` (or the platform-equivalent config directory). It uses `https://api.scalemax.pro/v1`, reads its credential from the private `~/.config/opencode/scalemax.key` file through OpenCode's `{file:...}` substitution, keeps unrelated providers and the user's non-ScaleMax default model, and loads every model available to the authenticated key. A fresh ScaleMax setup uses authenticated Haiku as `small_model` for quicker lightweight work. Each generated model has an explicit output limit of at most 4096 tokens so OpenCode does not send an unsupported default limit.
+ScaleMax merges a named `scalemax` provider into `~/.config/opencode/opencode.json` (or the platform-equivalent config directory). It uses `https://api.scalemax.pro/v1`, reads its credential from the private `~/.config/opencode/scalemax.key` file through OpenCode's `{file:...}` substitution, keeps unrelated providers and the user's non-ScaleMax default model, and exposes only authenticated Codex/OpenAI-family models. A fresh ScaleMax setup uses an authenticated GPT mini model as `small_model` when available. Each generated model has an explicit output limit of at most 4096 tokens so OpenCode does not send an unsupported default limit.
 
 ### OpenClaw
 
-ScaleMax merges a native `anthropic-messages` provider into `~/.openclaw/openclaw.json`, using the Anthropic origin `https://api.scalemax.pro`. The API key and the compatibility User-Agent are both OpenClaw file-backed SecretRefs stored in private `0600` files under `~/.openclaw/secrets/`; neither value is embedded in the provider JSON. The migration removes exact plaintext ScaleMax key copies from generated agent model registries. It adds every authenticated model to the provider and agent allowlist, uses authenticated Haiku for utility work when ScaleMax is the active provider, caps generated output limits at 4096 tokens, explicitly denies private-network routing for the public gateway, and preserves unrelated providers and agent settings. Legacy ScaleMax artifacts are removed only when they carry the ScaleMax managed marker.
+ScaleMax partitions OpenClaw models into native `openai-responses` (`scalemax-codex`, `/v1`) and `anthropic-messages` (`scalemax-claude`, origin) providers. The API key and compatibility User-Agent are OpenClaw file-backed SecretRefs stored in private `0600` files under `~/.openclaw/secrets/`; neither value is embedded in the main provider JSON. Migration removes the obsolete mixed provider, preserves the active model family, and scrubs plaintext credentials from generated ScaleMax agent registries even when they contain an older key. Output is capped at 4096 tokens, private-network routing is denied for the public gateway, and unrelated providers and agent settings are preserved.
 
 ### Hermes
 
-ScaleMax merges a named custom provider into `~/.hermes/config.yaml` and stores its credential in `~/.hermes/.env` with private permissions. Hermes uses OpenAI chat-completions routing at `https://api.scalemax.pro/v1`, a scoped `ScaleMax-Hermes/1.0` user agent, and a 4096-token output cap. Existing non-ScaleMax providers and defaults are preserved; a fresh Hermes config activates `custom:scalemax` automatically.
+ScaleMax creates family-specific Hermes providers in `~/.hermes/config.yaml` and stores one credential in `~/.hermes/.env` with private permissions. `scalemax-codex` uses Hermes's `codex_responses` transport at `/v1`; `scalemax-claude` uses `anthropic_messages` at the gateway origin. Both use a scoped `ScaleMax-Hermes/1.0` user agent and a 4096-token output cap. Existing non-ScaleMax providers and defaults are preserved, and the obsolete mixed provider is migrated safely.
+
+### 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. Reload VS Code once so Roo imports the Codex/OpenAI-only profile into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
 
 ### Cursor BYOK routing on macOS
 
@@ -281,7 +290,7 @@ Never publish over an existing npm version. Use semantic versioning for every re
 - Invalid JSON/JSON5 client files fail closed instead of being replaced; valid JSON5 values are merged safely.
 - Backup directories are user-only and backup files are written with private permissions.
 - API keys are masked in terminal output.
-- Claude Code, OpenCode, OpenClaw, and Hermes keep generated client credentials in private files rather than shared provider configuration blocks.
+- Codex, Claude Code, OpenCode, OpenClaw, Hermes, and the Roo Code import handoff keep generated client credentials in private files rather than shared provider configuration blocks.
 - The published npm package contains only runtime files: `dist/`, `README.md`, `LICENSE`, and `package.json`.
 - Tests, TypeScript source, scripts, local caches, `.env` files, tarballs, and `node_modules` are excluded from the published package.
 

package/dist/clients.js

@@ -2,6 +2,8 @@ import * as codexDetect from './detect/codex.js';
 import * as codexConfig from './configure/codex.js';
 import * as cursorDetect from './detect/cursor.js';
 import * as cursorConfig from './configure/cursor.js';
+import * as rooCodeDetect from './detect/roo-code.js';
+import * as rooCodeConfig from './configure/roo-code.js';
 import * as traeSoloDetect from './detect/trae-solo.js';
 import * as traeSoloConfig from './configure/trae-solo.js';
 import * as claudeDetect from './detect/claude.js';
@@ -19,6 +21,7 @@ import * as apiCodeConfig from './configure/api-code.js';
 export const clients = [
     { id: 'codex', name: 'Codex', detect: codexDetect.detect, install: codexConfig.install, configure: codexConfig.configure, verify: codexConfig.verify, launch: codexConfig.launch, remove: codexConfig.remove },
     { id: 'cursor', name: 'Cursor', detect: cursorDetect.detect, configure: cursorConfig.configure, verify: cursorConfig.verify, remove: cursorConfig.remove },
+    { id: 'roo-code', name: 'Roo Code (VS Code)', detect: rooCodeDetect.detect, configure: rooCodeConfig.configure, verify: rooCodeConfig.verify, remove: rooCodeConfig.remove },
     { id: 'trae-solo', name: 'TRAE SOLO', detect: traeSoloDetect.detect, configure: traeSoloConfig.configure, remove: traeSoloConfig.remove },
     { id: 'claude', name: 'Claude Code', detect: claudeDetect.detect, configure: claudeConfig.configure, verify: claudeConfig.verify, remove: claudeConfig.remove },
     { id: 'opencode', name: 'OpenCode', detect: opencodeDetect.detect, configure: opencodeConfig.configure, verify: opencodeConfig.verify, remove: opencodeConfig.remove },

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', 'opencode', '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/codex.js

@@ -5,17 +5,16 @@ import { codexAuthPath, codexConfigPath } from './paths.js';
 import { atomicWrite, backupFile, listBackups } from '../utils/fs.js';
 import { GENERATED_HEADER } from '../constants.js';
 import { commandExists } from '../utils/exec.js';
+import { preferredOpenAiModel } from './models.js';
 const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
 const fallbackModel = 'gpt-5.5';
 const reasoningEffort = 'medium';
 function selectedModel(ctx) {
-    const ids = new Set((ctx.models || []).map(m => m.id));
-    for (const candidate of ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.5', 'gpt-5.4', 'gpt-5.3-codex'])
-        if (ids.has(candidate))
-            return candidate;
-    return ctx.models?.[0]?.id || fallbackModel;
+    if (!ctx.models)
+        return fallbackModel;
+    return preferredOpenAiModel(ctx);
 }
 function scalemaxCodexBlock(baseUrl, model = fallbackModel) {
     return `# ${GENERATED_HEADER}\nmodel = "${model}"\nmodel_provider = "${provider}"\nmodel_reasoning_effort = "${reasoningEffort}"\n# ScaleMax models are loaded from the authenticated live model catalog.\n\n[model_providers.${provider}]\nname = "ScaleMax"\nbase_url = "${baseUrl}"\nwire_api = "responses"\nrequires_openai_auth = true\n`;
@@ -195,7 +194,7 @@ export async function verifyCodexConfiguration(ctx) {
         const res = await fetch(`${ctx.baseUrl}/responses`, {
             method: 'POST',
             headers: { Authorization: `Bearer ${ctx.apiKey}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ model, input: 'Say OK', stream: false }),
+            body: JSON.stringify({ model, input: 'Reply K', stream: false, max_output_tokens: 8 }),
             signal: AbortSignal.timeout(15000)
         });
         if (res.status === 404)
@@ -204,6 +203,12 @@ export async function verifyCodexConfiguration(ctx) {
             errors.push(`ScaleMax rejected the API key on /v1/responses with HTTP ${res.status}`);
         else if (!res.ok)
             warnings.push(`ScaleMax /v1/responses probe returned HTTP ${res.status}`);
+        else {
+            const body = await res.json().catch(() => undefined);
+            const hasOutput = typeof body?.output_text === 'string' || (Array.isArray(body?.output) && body.output.length > 0);
+            if (!body?.id || !hasOutput)
+                errors.push('ScaleMax /v1/responses returned a success status without a valid Responses payload.');
+        }
     }
     catch (err) {
         warnings.push(`Could not probe ScaleMax /v1/responses: ${err instanceof Error ? err.message : String(err)}`);

package/dist/configure/hermes.js

@@ -4,11 +4,14 @@ import { parseDocument } from 'yaml';
 import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
 import { isScaleMaxManagedText } from './common.js';
-import { modelIds, openAiBaseUrl, preferredModel } from './models.js';
+import { anthropicModelIds, anthropicOrigin, openAiBaseUrl, openAiModelIds, preferredAnthropicModel, preferredOpenAiModel } from './models.js';
 const id = 'hermes';
 const name = 'Hermes';
 const envKey = 'SCALEMAX_HERMES_API_KEY';
 const envMarker = '# ScaleMax managed Hermes API key';
+const legacyProviderName = 'scalemax';
+const codexProviderName = 'scalemax-codex';
+const claudeProviderName = 'scalemax-claude';
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -33,8 +36,8 @@ function parseYaml(text) {
         doc.contents = doc.createNode({});
     return doc;
 }
-function modelMetadata(ctx) {
-    return Object.fromEntries(modelIds(ctx).map(modelId => {
+function modelMetadata(ctx, ids) {
+    return Object.fromEntries(ids.map(modelId => {
         const model = (ctx.models || []).find(candidate => candidate.id === modelId);
         const metadata = {};
         if (model?.context_window)
@@ -61,21 +64,39 @@ export async function configure(ctx) {
     const originalEnv = await fs.readFile(secrets, 'utf8').catch(() => '');
     const doc = parseYaml(originalConfig);
     const data = asRecord(doc.toJS());
-    const providers = Array.isArray(data.custom_providers) ? data.custom_providers.filter((provider) => provider?.name !== 'scalemax') : [];
-    providers.push({
-        name: 'scalemax',
-        base_url: openAiBaseUrl(ctx.baseUrl),
-        key_env: envKey,
-        api_mode: 'chat_completions',
-        extra_headers: { 'User-Agent': 'ScaleMax-Hermes/1.0' },
-        max_output_tokens: 4096,
-        models: modelMetadata(ctx)
-    });
+    const codexIds = openAiModelIds(ctx);
+    const claudeIds = anthropicModelIds(ctx);
+    const managedNames = new Set([legacyProviderName, codexProviderName, claudeProviderName]);
+    const providers = Array.isArray(data.custom_providers) ? data.custom_providers.filter((provider) => !managedNames.has(provider?.name)) : [];
+    if (codexIds.length)
+        providers.push({
+            name: codexProviderName,
+            base_url: openAiBaseUrl(ctx.baseUrl),
+            key_env: envKey,
+            api_mode: 'codex_responses',
+            extra_headers: { 'User-Agent': 'ScaleMax-Hermes/1.0' },
+            max_output_tokens: 4096,
+            models: modelMetadata(ctx, codexIds)
+        });
+    if (claudeIds.length)
+        providers.push({
+            name: claudeProviderName,
+            base_url: anthropicOrigin(ctx.baseUrl),
+            key_env: envKey,
+            api_mode: 'anthropic_messages',
+            extra_headers: { 'User-Agent': 'ScaleMax-Hermes/1.0' },
+            max_output_tokens: 4096,
+            models: modelMetadata(ctx, claudeIds)
+        });
     doc.set('custom_providers', providers);
     const currentModel = asRecord(data.model);
-    const activatesScaleMax = !currentModel.provider || String(currentModel.provider).startsWith('custom:scalemax');
+    const currentProvider = String(currentModel.provider || '');
+    const activatesScaleMax = !currentProvider || currentProvider.startsWith('custom:scalemax');
     if (activatesScaleMax) {
-        doc.set('model', { ...currentModel, provider: 'custom:scalemax', default: preferredModel(ctx), max_tokens: 4096 });
+        const keepClaude = currentProvider === `custom:${claudeProviderName}` || claudeIds.includes(String(currentModel.default || ''));
+        const activeName = codexIds.length && !keepClaude ? codexProviderName : claudeProviderName;
+        const activeModel = activeName === codexProviderName ? preferredOpenAiModel(ctx) : preferredAnthropicModel(ctx);
+        doc.set('model', { ...currentModel, provider: `custom:${activeName}`, default: activeModel, max_tokens: 4096 });
     }
     const nextConfig = String(doc);
     const nextEnv = managedEnv(originalEnv, ctx.apiKey);
@@ -83,7 +104,7 @@ export async function configure(ctx) {
         await fs.chmod(file, 0o600).catch(() => undefined);
         await fs.chmod(secrets, 0o600).catch(() => undefined);
         await removeLegacyArtifact(ctx);
-        return { id, name, changed: false, path: file, message: `already current with ${modelIds(ctx).length} models and a private credential` };
+        return { id, name, changed: false, path: file, message: `already current with ${codexIds.length} Codex/OpenAI and ${claudeIds.length} Claude models and a private credential` };
     }
     const backups = [await backupFile(file, ctx.home), await backupFile(secrets, ctx.home)].filter(Boolean);
     try {
@@ -102,25 +123,33 @@ export async function configure(ctx) {
             await fs.remove(secrets).catch(() => undefined);
         throw error;
     }
-    return { id, name, changed: true, path: file, message: `configured named ScaleMax provider with ${modelIds(ctx).length} models${backups.length ? ' (backups created)' : ''}` };
+    return { id, name, changed: true, path: file, message: `configured family-specific ScaleMax providers with ${codexIds.length} Codex/OpenAI and ${claudeIds.length} Claude models${backups.length ? ' (backups created)' : ''}` };
 }
 export async function verify(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
     const secrets = envPath(ctx.home);
     const doc = parseYaml(await fs.readFile(file, 'utf8'));
     const data = asRecord(doc.toJS());
-    const provider = (Array.isArray(data.custom_providers) ? data.custom_providers : []).find((candidate) => candidate?.name === 'scalemax');
-    if (!provider || provider.base_url !== openAiBaseUrl(ctx.baseUrl) || provider.key_env !== envKey || provider.api_mode !== 'chat_completions' || provider.extra_headers?.['User-Agent'] !== 'ScaleMax-Hermes/1.0') {
-        throw new Error('Hermes ScaleMax custom provider settings are incomplete.');
+    const providers = Array.isArray(data.custom_providers) ? data.custom_providers : [];
+    const codexIds = openAiModelIds(ctx);
+    const claudeIds = anthropicModelIds(ctx);
+    const codex = providers.find((candidate) => candidate?.name === codexProviderName);
+    const claude = providers.find((candidate) => candidate?.name === claudeProviderName);
+    const valid = (provider, baseUrl, apiMode, ids) => provider
+        && provider.base_url === baseUrl && provider.key_env === envKey && provider.api_mode === apiMode
+        && provider.extra_headers?.['User-Agent'] === 'ScaleMax-Hermes/1.0'
+        && Object.keys(asRecord(provider.models)).length === ids.length
+        && ids.every(model => Object.hasOwn(asRecord(provider.models), model));
+    if ((codexIds.length ? !valid(codex, openAiBaseUrl(ctx.baseUrl), 'codex_responses', codexIds) : Boolean(codex))
+        || (claudeIds.length ? !valid(claude, anthropicOrigin(ctx.baseUrl), 'anthropic_messages', claudeIds) : Boolean(claude))) {
+        throw new Error('Hermes ScaleMax family-specific custom provider settings are incomplete.');
     }
-    const configured = Object.keys(asRecord(provider.models));
-    const missing = modelIds(ctx).filter(model => !configured.includes(model));
     const env = await fs.readFile(secrets, 'utf8').catch(() => '');
-    if (missing.length || !env.includes(envMarker) || !env.includes(`${envKey}=${ctx.apiKey}`))
+    if (!env.includes(envMarker) || !env.includes(`${envKey}=${ctx.apiKey}`))
         throw new Error('Hermes is missing authenticated ScaleMax models or credentials.');
-    if (data?.model?.provider === 'custom:scalemax' && data?.model?.max_tokens !== 4096)
+    if (String(data?.model?.provider || '').startsWith('custom:scalemax') && data?.model?.max_tokens !== 4096)
         throw new Error('Hermes active ScaleMax model must use max_tokens 4096.');
-    return { id, name, changed: false, path: file, message: `verified ${configured.length} ScaleMax models` };
+    return { id, name, changed: false, path: file, message: `verified ${codexIds.length} Codex/OpenAI and ${claudeIds.length} Claude models` };
 }
 export async function remove(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
@@ -131,20 +160,23 @@ export async function remove(ctx) {
     const doc = parseYaml(text);
     const data = asRecord(doc.toJS());
     const providers = Array.isArray(data.custom_providers) ? data.custom_providers : [];
-    const managedProvider = providers.find((provider) => provider?.name === 'scalemax' && provider?.base_url === openAiBaseUrl(ctx.baseUrl));
-    if (!managedProvider)
+    const managedNames = new Set([legacyProviderName, codexProviderName, claudeProviderName]);
+    const managedProviders = providers.filter((provider) => managedNames.has(provider?.name)
+        && (provider?.base_url === openAiBaseUrl(ctx.baseUrl) || provider?.base_url === anthropicOrigin(ctx.baseUrl)));
+    if (!managedProviders.length)
         return { id, name, changed: false, path: file, message: 'left unmanaged configuration unchanged' };
-    const managedModels = Object.keys(asRecord(managedProvider.models));
-    const remaining = providers.filter((provider) => provider?.name !== 'scalemax');
+    const managedModels = managedProviders.flatMap((provider) => Object.keys(asRecord(provider.models)));
+    const remaining = providers.filter((provider) => !managedProviders.includes(provider));
     if (remaining.length)
         doc.set('custom_providers', remaining);
     else
         doc.delete('custom_providers');
-    if (data?.model?.provider === 'custom:scalemax')
+    const activeManaged = String(data?.model?.provider || '').startsWith('custom:scalemax');
+    if (activeManaged)
         doc.deleteIn(['model', 'provider']);
-    if (data?.model?.provider === 'custom:scalemax' && managedModels.includes(String(data?.model?.default || '')))
+    if (activeManaged && managedModels.includes(String(data?.model?.default || '')))
         doc.deleteIn(['model', 'default']);
-    if (data?.model?.provider === 'custom:scalemax' && data?.model?.max_tokens === 4096)
+    if (activeManaged && data?.model?.max_tokens === 4096)
         doc.deleteIn(['model', 'max_tokens']);
     const currentEnv = await fs.readFile(secrets, 'utf8').catch(() => '');
     await backupFile(file, ctx.home);

package/dist/configure/models.d.ts

@@ -1,7 +1,21 @@
 import { ConfigureContext } from '../types/client.js';
 export declare function modelIds(ctx: ConfigureContext): string[];
+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,18 +1,56 @@
-const preferred = [
+import { isAnthropicModel, isRetiredModelId } from '../utils/api.js';
+const preferredAnthropic = [
     'claude-opus-4-8',
     'claude-sonnet-5',
     'claude-opus-4-7',
     'claude-opus-4-6',
-    'claude-haiku-4-5-20251001',
+    'claude-haiku-4-5-20251001'
+];
+const preferredOpenAi = [
+    'gpt-5.6-terra',
+    'gpt-5.6-luna',
+    '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(id => id && !isRetiredModelId(id)))];
+}
+export function openAiModelIds(ctx) {
+    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)
+        if (ids.includes(candidate))
+            return candidate;
+    if (ids.length)
+        return ids[0];
+    throw new Error(`No compatible ${family} models are available for this API key; the client was not changed.`);
+}
+export function preferredAnthropicModel(ctx) {
+    return preferredFrom(anthropicModelIds(ctx), preferredAnthropic, 'Claude');
+}
+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 preferred)
+    for (const candidate of [...preferredAnthropic, ...preferredOpenAi])
         if (ids.includes(candidate))
             return candidate;
     if (ids.length)
@@ -24,6 +62,15 @@ export function fastModel(ctx) {
     return ids.find(id => id === 'claude-haiku-4-5-20251001')
         || ids.find(id => /(^|-)haiku([-.]|$)/i.test(id));
 }
+export function fastOpenAiModel(ctx) {
+    const ids = openAiModelIds(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/openclaw.js

@@ -3,7 +3,7 @@ import fs from 'fs-extra';
 import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
 import { isScaleMaxManagedText, writeMergedJsonConfig } from './common.js';
-import { anthropicOrigin, fastModel, modelIds, modelName, preferredModel } from './models.js';
+import { anthropicModelIds, anthropicOrigin, fastModel, fastOpenAiModel, modelName, openAiBaseUrl, openAiModelIds, preferredAnthropicModel, preferredOpenAiModel } from './models.js';
 import { removeClientSecret, rollbackClientSecret, verifyClientSecret, writeClientSecret } from './client-secret.js';
 const id = 'openclaw';
 const name = 'OpenClaw';
@@ -14,22 +14,33 @@ const userAgentProviderId = 'scalemax_cli_user_agent';
 const userAgentConfigPath = '~/.openclaw/secrets/scalemax-user-agent';
 const userAgentValue = 'ScaleMax-OpenClaw/1.0';
 const userAgentReference = { source: 'file', provider: userAgentProviderId, id: 'value' };
+const legacyProviderName = 'scalemax';
+const codexProviderName = 'scalemax-codex';
+const claudeProviderName = 'scalemax-claude';
 function secretPath(home) { return path.join(home, '.openclaw', 'secrets', 'scalemax-api-key'); }
 function userAgentPath(home) { return path.join(home, '.openclaw', 'secrets', 'scalemax-user-agent'); }
 function userAgentContext(ctx) { return { ...ctx, apiKey: userAgentValue }; }
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
-function entries(ctx) {
-    return modelIds(ctx).map(modelId => {
+function isScaleMaxBaseUrl(value) {
+    try {
+        return new URL(String(value)).hostname === 'api.scalemax.pro';
+    }
+    catch {
+        return false;
+    }
+}
+function entries(ctx, ids, family) {
+    return ids.map(modelId => {
         const metadata = (ctx.models || []).find(model => model.id === modelId);
         const result = {
             id: modelId,
             name: modelName(ctx, modelId),
-            input: modelId.startsWith('claude-') && !modelId.startsWith('claude-fable-') ? ['text', 'image'] : ['text'],
+            input: family === 'anthropic' ? ['text', 'image'] : ['text'],
             maxTokens: Math.min(metadata?.max_output_tokens || 4096, 4096)
         };
-        if (metadata?.context_window || modelId.startsWith('claude-'))
+        if (metadata?.context_window || family === 'anthropic')
             result.contextWindow = metadata?.context_window || 200000;
         return result;
     });
@@ -65,10 +76,14 @@ async function scrubGeneratedPlaintextCredentials(ctx) {
         const roots = [asRecord(data.providers), asRecord(asRecord(data.models).providers)];
         let scrubbed = false;
         for (const providers of roots) {
-            const provider = asRecord(providers.scalemax);
-            if (provider.baseUrl === anthropicOrigin(ctx.baseUrl) && provider.apiKey === ctx.apiKey) {
-                delete provider.apiKey;
-                scrubbed = true;
+            for (const [providerName, rawProvider] of Object.entries(providers)) {
+                const provider = asRecord(rawProvider);
+                const isScaleMax = [legacyProviderName, codexProviderName, claudeProviderName].includes(providerName)
+                    && isScaleMaxBaseUrl(provider.baseUrl);
+                if (isScaleMax && typeof provider.apiKey === 'string') {
+                    delete provider.apiKey;
+                    scrubbed = true;
+                }
             }
         }
         if (!scrubbed)
@@ -81,8 +96,12 @@ async function scrubGeneratedPlaintextCredentials(ctx) {
 }
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const primary = `scalemax/${preferredModel(ctx)}`;
-    const quick = fastModel(ctx);
+    const codexIds = openAiModelIds(ctx);
+    const claudeIds = anthropicModelIds(ctx);
+    const codexPrimary = codexIds.length ? `${codexProviderName}/${preferredOpenAiModel(ctx)}` : undefined;
+    const claudePrimary = claudeIds.length ? `${claudeProviderName}/${preferredAnthropicModel(ctx)}` : undefined;
+    const codexQuick = fastOpenAiModel(ctx);
+    const claudeQuick = fastModel(ctx);
     let secret = { changed: false };
     let userAgentSecret = { changed: false };
     let result;
@@ -97,16 +116,52 @@ export async function configure(ctx) {
             const agents = asRecord(existing.agents);
             const defaults = asRecord(agents.defaults);
             const allowlist = asRecord(defaults.models);
-            for (const modelId of modelIds(ctx))
-                allowlist[`scalemax/${modelId}`] = asRecord(allowlist[`scalemax/${modelId}`]);
+            for (const key of Object.keys(allowlist)) {
+                if (key.startsWith(`${legacyProviderName}/`) || key.startsWith(`${codexProviderName}/`) || key.startsWith(`${claudeProviderName}/`))
+                    delete allowlist[key];
+            }
+            for (const modelId of codexIds)
+                allowlist[`${codexProviderName}/${modelId}`] = {};
+            for (const modelId of claudeIds)
+                allowlist[`${claudeProviderName}/${modelId}`] = {};
             const currentModel = defaults.model;
             const currentPrimary = typeof currentModel === 'string' ? currentModel : asRecord(currentModel).primary;
-            const activatesScaleMax = !currentPrimary || String(currentPrimary).startsWith('scalemax/');
+            const activatesScaleMax = !currentPrimary || String(currentPrimary).startsWith('scalemax');
+            const currentId = String(currentPrimary || '').split('/').slice(1).join('/');
+            const keepClaude = String(currentPrimary || '').startsWith(`${claudeProviderName}/`) || claudeIds.includes(currentId);
+            const primary = keepClaude ? claudePrimary || codexPrimary : codexPrimary || claudePrimary;
+            const usesClaude = Boolean(primary?.startsWith(`${claudeProviderName}/`));
             const nextModel = activatesScaleMax
-                ? { ...asRecord(currentModel), primary }
+                ? { ...asRecord(currentModel), ...(primary ? { primary } : {}) }
                 : currentModel;
             const currentUtility = typeof defaults.utilityModel === 'string' ? defaults.utilityModel : undefined;
-            const utilityModel = quick && (activatesScaleMax || currentUtility?.startsWith('scalemax/')) ? `scalemax/${quick}` : currentUtility;
+            const quick = usesClaude ? claudeQuick : codexQuick;
+            const utilityProvider = usesClaude ? claudeProviderName : codexProviderName;
+            const utilityModel = quick && (activatesScaleMax || currentUtility?.startsWith('scalemax')) ? `${utilityProvider}/${quick}` : currentUtility;
+            const nextProviders = { ...providers };
+            delete nextProviders[legacyProviderName];
+            if (codexIds.length)
+                nextProviders[codexProviderName] = {
+                    baseUrl: openAiBaseUrl(ctx.baseUrl),
+                    apiKey: secretReference,
+                    api: 'openai-responses',
+                    maxTokens: 4096,
+                    request: { headers: { 'User-Agent': userAgentReference }, allowPrivateNetwork: false },
+                    models: entries(ctx, codexIds, 'openai')
+                };
+            else
+                delete nextProviders[codexProviderName];
+            if (claudeIds.length)
+                nextProviders[claudeProviderName] = {
+                    baseUrl: anthropicOrigin(ctx.baseUrl),
+                    apiKey: secretReference,
+                    api: 'anthropic-messages',
+                    maxTokens: 4096,
+                    request: { headers: { 'User-Agent': userAgentReference }, allowPrivateNetwork: false },
+                    models: entries(ctx, claudeIds, 'anthropic')
+                };
+            else
+                delete nextProviders[claudeProviderName];
             return JSON.stringify({
                 ...existing,
                 secrets: {
@@ -120,20 +175,7 @@ export async function configure(ctx) {
                 models: {
                     ...modelsRoot,
                     mode: modelsRoot.mode || 'merge',
-                    providers: {
-                        ...providers,
-                        scalemax: {
-                            baseUrl: anthropicOrigin(ctx.baseUrl),
-                            apiKey: secretReference,
-                            api: 'anthropic-messages',
-                            maxTokens: 4096,
-                            request: {
-                                headers: { 'User-Agent': userAgentReference },
-                                allowPrivateNetwork: false
-                            },
-                            models: entries(ctx)
-                        }
-                    }
+                    providers: nextProviders
                 },
                 agents: {
                     ...agents,
@@ -149,25 +191,37 @@ export async function configure(ctx) {
     }
     await removeLegacyArtifact(ctx);
     const scrubbed = await scrubGeneratedPlaintextCredentials(ctx);
-    return { ...result, changed: result.changed || secret.changed || userAgentSecret.changed || scrubbed > 0, message: `configured native Anthropic provider with ${modelIds(ctx).length} models and file-backed SecretRefs${quick ? `; ${quick} handles utility work` : ''}${scrubbed ? `; scrubbed ${scrubbed} generated credential ${scrubbed === 1 ? 'copy' : 'copies'}` : ''}` };
+    return { ...result, changed: result.changed || secret.changed || userAgentSecret.changed || scrubbed > 0, message: `configured native Responses (${codexIds.length}) and Anthropic Messages (${claudeIds.length}) providers with file-backed SecretRefs${scrubbed ? `; scrubbed ${scrubbed} generated credential ${scrubbed === 1 ? 'copy' : 'copies'}` : ''}` };
 }
 export async function verify(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
     const config = await fs.readJson(file);
-    const provider = config?.models?.providers?.scalemax;
+    const codex = config?.models?.providers?.[codexProviderName];
+    const claude = config?.models?.providers?.[claudeProviderName];
     const secretProvider = config?.secrets?.providers?.[secretProviderId];
     const userAgentProvider = config?.secrets?.providers?.[userAgentProviderId];
-    const userAgent = provider?.request?.headers?.['User-Agent'];
-    if (provider?.baseUrl !== anthropicOrigin(ctx.baseUrl) || provider?.apiKey?.source !== secretReference.source || provider?.apiKey?.provider !== secretReference.provider || provider?.apiKey?.id !== secretReference.id || provider?.api !== 'anthropic-messages' || secretProvider?.source !== 'file' || secretProvider?.path !== secretConfigPath || secretProvider?.mode !== 'singleValue' || userAgent?.source !== userAgentReference.source || userAgent?.provider !== userAgentReference.provider || userAgent?.id !== userAgentReference.id || userAgentProvider?.source !== 'file' || userAgentProvider?.path !== userAgentConfigPath || userAgentProvider?.mode !== 'singleValue') {
+    const codexIds = openAiModelIds(ctx);
+    const claudeIds = anthropicModelIds(ctx);
+    const valid = (provider, baseUrl, api, ids) => {
+        const userAgent = provider?.request?.headers?.['User-Agent'];
+        const configured = new Set((Array.isArray(provider?.models) ? provider.models : []).map((model) => model?.id));
+        return provider?.baseUrl === baseUrl && provider?.apiKey?.source === secretReference.source
+            && provider?.apiKey?.provider === secretReference.provider && provider?.apiKey?.id === secretReference.id
+            && provider?.api === api && provider?.request?.allowPrivateNetwork === false
+            && userAgent?.source === userAgentReference.source && userAgent?.provider === userAgentReference.provider
+            && userAgent?.id === userAgentReference.id && configured.size === ids.length && ids.every(model => configured.has(model));
+    };
+    if ((codexIds.length ? !valid(codex, openAiBaseUrl(ctx.baseUrl), 'openai-responses', codexIds) : Boolean(codex))
+        || (claudeIds.length ? !valid(claude, anthropicOrigin(ctx.baseUrl), 'anthropic-messages', claudeIds) : Boolean(claude))
+        || secretProvider?.source !== 'file' || secretProvider?.path !== secretConfigPath || secretProvider?.mode !== 'singleValue'
+        || userAgentProvider?.source !== 'file' || userAgentProvider?.path !== userAgentConfigPath || userAgentProvider?.mode !== 'singleValue') {
         throw new Error('OpenClaw ScaleMax provider settings are incomplete.');
     }
     await verifyClientSecret(secretPath(ctx.home), ctx);
     await verifyClientSecret(userAgentPath(ctx.home), userAgentContext(ctx));
-    const configured = new Set((Array.isArray(provider.models) ? provider.models : []).map((model) => model?.id));
-    const missing = modelIds(ctx).filter(model => !configured.has(model));
-    if (missing.length)
-        throw new Error(`OpenClaw is missing ${missing.length} authenticated model(s).`);
-    return { id, name, changed: false, path: file, message: `verified ${configured.size} ScaleMax models` };
+    if (config?.models?.providers?.[legacyProviderName])
+        throw new Error('OpenClaw still contains the obsolete mixed ScaleMax provider.');
+    return { id, name, changed: false, path: file, message: `verified ${codexIds.length} Codex/OpenAI and ${claudeIds.length} Claude models` };
 }
 export async function remove(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
@@ -177,10 +231,16 @@ export async function remove(ctx) {
         return { id, name, changed: removed || removedUserAgent, path: file, message: removed || removedUserAgent ? 'removed orphaned ScaleMax OpenClaw credentials' : 'no ScaleMax configuration found' };
     }
     const config = await fs.readJson(file).catch(() => undefined);
-    if (!config?.models?.providers?.scalemax || config.models.providers.scalemax.baseUrl !== anthropicOrigin(ctx.baseUrl)) {
+    const providerRoot = asRecord(config?.models?.providers);
+    const managedNames = [legacyProviderName, codexProviderName, claudeProviderName].filter(providerName => {
+        const provider = asRecord(providerRoot[providerName]);
+        return [anthropicOrigin(ctx.baseUrl), openAiBaseUrl(ctx.baseUrl)].includes(String(provider.baseUrl || ''));
+    });
+    if (!managedNames.length) {
         return { id, name, changed: false, path: file, message: 'left unmanaged configuration unchanged' };
     }
-    delete config.models.providers.scalemax;
+    for (const providerName of managedNames)
+        delete config.models.providers[providerName];
     if (!Object.keys(config.models.providers).length)
         delete config.models.providers;
     if (Object.keys(config.models).length === 1 && config.models.mode === 'merge')
@@ -188,19 +248,19 @@ export async function remove(ctx) {
     const defaults = config?.agents?.defaults;
     if (defaults?.models && typeof defaults.models === 'object') {
         for (const key of Object.keys(defaults.models))
-            if (key.startsWith('scalemax/'))
+            if (key.startsWith('scalemax'))
                 delete defaults.models[key];
         if (!Object.keys(defaults.models).length)
             delete defaults.models;
     }
-    if (typeof defaults?.model === 'string' && defaults.model.startsWith('scalemax/'))
+    if (typeof defaults?.model === 'string' && defaults.model.startsWith('scalemax'))
         delete defaults.model;
-    if (defaults?.model?.primary?.startsWith?.('scalemax/')) {
+    if (defaults?.model?.primary?.startsWith?.('scalemax')) {
         delete defaults.model.primary;
         if (!Object.keys(defaults.model).length)
             delete defaults.model;
     }
-    if (typeof defaults?.utilityModel === 'string' && defaults.utilityModel.startsWith('scalemax/'))
+    if (typeof defaults?.utilityModel === 'string' && defaults.utilityModel.startsWith('scalemax'))
         delete defaults.utilityModel;
     if (defaults && !Object.keys(defaults).length)
         delete config.agents.defaults;

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 { fastModel, modelIds, modelName, openAiBaseUrl, preferredModel } 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';
@@ -32,8 +32,8 @@ function providerConfig(ctx) {
 }
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const selected = `scalemax/${preferredModel(ctx)}`;
-    const quick = fastModel(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,9 +66,11 @@ export async function verify(ctx) {
     }
     await verifyClientSecret(secretPath(ctx.home), ctx);
     const configured = Object.keys(asRecord(provider.models));
-    const missing = modelIds(ctx).filter(model => !configured.includes(model));
-    if (missing.length)
-        throw new Error(`OpenCode is missing ${missing.length} authenticated model(s).`);
+    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 chat model(s).`);
     return { id, name, changed: false, path: file, message: `verified ${configured.length} ScaleMax models` };
 }
 export async function remove(ctx) {

package/dist/configure/paths.js

@@ -9,6 +9,7 @@ export function clientConfigPath(id, home, platform, env = process.env) {
     switch (id) {
         case 'codex': return codexConfigPath(home);
         case 'cursor': return platform === 'win32' ? path.join(app, 'Cursor', 'User', 'settings.json') : platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'settings.json') : path.join(linux, 'Cursor', 'User', 'settings.json');
+        case 'roo-code': return platform === 'win32' ? path.join(app, 'Code', 'User', 'settings.json') : platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'Code', 'User', 'settings.json') : path.join(linux, 'Code', 'User', 'settings.json');
         case 'trae-solo': return path.join(home, '.scalemax', 'trae-solo.setup.json');
         case 'claude': return path.join(home, '.claude', 'settings.json');
         case 'opencode': return path.join(linux, 'opencode', 'opencode.json');
@@ -24,6 +25,7 @@ export function installHints(id, home, platform, env = process.env) {
     switch (id) {
         case 'codex': return [codexDir(home), path.join(linux, 'codex')];
         case 'cursor': return [platform === 'darwin' ? '/Applications/Cursor.app' : path.join(app, 'Cursor'), path.join(linux, 'Cursor')];
+        case 'roo-code': return [path.join(home, '.vscode', 'extensions'), path.join(home, '.vscode-insiders', 'extensions')];
         case 'trae-solo': return [platform === 'darwin' ? '/Applications/Trae.app' : path.join(app, 'Trae'), path.join(linux, 'Trae')];
         case 'claude': return [path.join(home, '.claude')];
         case 'opencode': return [path.join(linux, 'opencode')];

package/dist/configure/roo-code.d.ts

@@ -0,0 +1,4 @@
+import { ConfigureContext, ConfigureResult } from '../types/client.js';
+export declare function configure(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function verify(ctx: ConfigureContext): Promise<ConfigureResult>;
+export declare function remove(ctx: ConfigureContext): Promise<ConfigureResult>;

package/dist/configure/roo-code.js

@@ -0,0 +1,133 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import JSON5 from 'json5';
+import { atomicWrite, backupFile } from '../utils/fs.js';
+import { clientConfigPath } from './paths.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 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 {};
+    try {
+        const value = JSON5.parse(text);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('root value must be an object');
+        return value;
+    }
+    catch (error) {
+        throw new Error(`Roo Code cannot update invalid VS Code settings at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function handoff(ctx) {
+    const profile = profileFor(ctx);
+    return JSON.stringify({
+        providerProfiles: {
+            currentApiConfigName: profile.name,
+            apiConfigs: {
+                [profile.name]: {
+                    id: profile.id,
+                    apiProvider: 'openai',
+                    openAiBaseUrl: openAiBaseUrl(ctx.baseUrl),
+                    openAiApiKey: ctx.apiKey,
+                    openAiModelId: profile.model,
+                    openAiStreamingEnabled: true,
+                    includeMaxTokens: true
+                }
+            },
+            modeApiConfigs: {}
+        },
+        globalSettings: {}
+    }, null, 2) + '\n';
+}
+export async function configure(ctx) {
+    const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const profileFile = importPath(ctx.home);
+    const originalSettings = await fs.readFile(settingsFile, 'utf8').catch(() => '');
+    const originalProfile = await fs.readFile(profileFile, 'utf8').catch(() => '');
+    const settings = parseSettings(originalSettings, settingsFile);
+    const nextSettings = JSON.stringify({ ...settings, [importSetting]: importSettingValue }, null, 2) + '\n';
+    const nextProfile = handoff(ctx);
+    if (originalSettings === nextSettings && originalProfile === nextProfile) {
+        await fs.chmod(profileFile, 0o600).catch(() => undefined);
+        return { id, name, changed: false, path: profileFile, message: 'supported Roo Code auto-import handoff is already current; reload VS Code to consume it' };
+    }
+    const originals = new Map([[settingsFile, originalSettings], [profileFile, originalProfile]]);
+    await backupFile(settingsFile, ctx.home);
+    await backupFile(profileFile, ctx.home);
+    try {
+        await atomicWrite(profileFile, nextProfile, 0o600, ctx.platform);
+        await atomicWrite(settingsFile, nextSettings, 0o600, ctx.platform);
+    }
+    catch (error) {
+        for (const [file, original] of originals) {
+            if (original)
+                await atomicWrite(file, original, 0o600, ctx.platform);
+            else
+                await fs.remove(file).catch(() => undefined);
+        }
+        throw error;
+    }
+    return { id, name, changed: true, path: profileFile, message: 'created a private, supported auto-import handoff; reload VS Code so Roo Code imports the profile into SecretStorage' };
+}
+export async function verify(ctx) {
+    const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const profileFile = importPath(ctx.home);
+    const settings = parseSettings(await fs.readFile(settingsFile, 'utf8'), settingsFile);
+    const profile = await fs.readJson(profileFile).catch(() => undefined);
+    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.');
+    }
+    if (ctx.platform !== 'win32' && ((await fs.stat(profileFile)).mode & 0o077) !== 0)
+        throw new Error('Roo Code import handoff permissions are too broad.');
+    return { id, name, changed: false, path: profileFile, message: 'verified supported auto-import handoff (runtime activation requires a VS Code reload)' };
+}
+export async function remove(ctx) {
+    const settingsFile = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const profileFile = importPath(ctx.home);
+    let changed = false;
+    if (await fs.pathExists(settingsFile)) {
+        const text = await fs.readFile(settingsFile, 'utf8');
+        const settings = parseSettings(text, settingsFile);
+        if (settings[importSetting] === importSettingValue) {
+            delete settings[importSetting];
+            await backupFile(settingsFile, ctx.home);
+            await atomicWrite(settingsFile, JSON.stringify(settings, null, 2) + '\n', 0o600, ctx.platform);
+            changed = true;
+        }
+    }
+    if (await fs.pathExists(profileFile)) {
+        const profile = await fs.readJson(profileFile).catch(() => undefined);
+        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;
+        }
+    }
+    return { id, name, changed, path: profileFile, message: changed ? 'removed only the ScaleMax Roo Code auto-import handoff' : 'no ScaleMax Roo Code handoff found' };
+}

package/dist/configure/templates.js

@@ -11,7 +11,7 @@ export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
     }, null, 2) + '\n';
 }
 export function continueConfig(apiKey, baseUrl) {
-    const models = ['fable-5', 'fable-5-ultra', 'gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review'];
+    const models = ['fable-5', 'gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'codex-auto-review'];
     return JSON.stringify({
         models: models.map(model => ({
             title: `ScaleMax ${model}`,

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/detect/codex.js

@@ -15,5 +15,17 @@ export async function detect(ctx) {
         paths.push(auth);
     if (!paths.length && await fs.pathExists(codexDir))
         paths.push(codexDir);
-    return { id: 'codex', name: 'Codex', installed: executable, reason: executable ? undefined : (paths.length ? 'configuration exists but codex executable is missing' : 'not detected'), paths, executable, configured: await fs.pathExists(config) && await fs.pathExists(auth), installable: true };
+    let configured = false;
+    if (await fs.pathExists(config) && await fs.pathExists(auth)) {
+        const configText = await fs.readFile(config, 'utf8').catch(() => '');
+        const authJson = await fs.readJson(auth).catch(() => ({}));
+        configured = /^\s*model_provider\s*=\s*["']scalemax["']/m.test(configText)
+            && /\[model_providers\.scalemax\]/.test(configText)
+            && /^\s*wire_api\s*=\s*["']responses["']/m.test(configText)
+            && /^\s*base_url\s*=\s*["']https:\/\/api\.scalemax\.pro\/(?:token\/)?v1\/?["']/m.test(configText)
+            && authJson.auth_mode === 'apikey'
+            && typeof authJson.OPENAI_API_KEY === 'string'
+            && /^sm_(?:live|dev|trial)_/.test(authJson.OPENAI_API_KEY);
+    }
+    return { id: 'codex', name: 'Codex', installed: executable, reason: executable ? undefined : (paths.length ? 'configuration exists but codex executable is missing' : 'not detected'), paths, executable, configured, installable: true };
 }

package/dist/detect/common.js

@@ -3,7 +3,7 @@ import { commandExists } from '../utils/exec.js';
 import { clientConfigPath, installHints } from '../configure/paths.js';
 import { GENERATED_HEADER } from '../constants.js';
 const commands = {
-    codex: ['codex'], cursor: ['cursor'], 'trae-solo': ['trae', 'trae-solo'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], 'cherry-studio': ['cherry-studio', 'cherrystudio'], 'api-code': []
+    codex: ['codex'], cursor: ['cursor'], 'roo-code': ['code'], 'trae-solo': ['trae', 'trae-solo'], claude: ['claude'], opencode: ['opencode'], openclaw: ['openclaw'], hermes: ['hermes'], 'cherry-studio': ['cherry-studio', 'cherrystudio'], 'api-code': []
 };
 const guiPathDetection = new Set(['trae-solo', 'cherry-studio']);
 function hasNativeScaleMaxConfig(id, text) {
@@ -12,13 +12,13 @@ function hasNativeScaleMaxConfig(id, text) {
     if (!text.includes('api.scalemax.pro'))
         return false;
     if (id === 'hermes')
-        return /(?:^|\n)\s*-?\s*name:\s*["']?scalemax["']?\s*(?:#.*)?(?:\n|$)/i.test(text);
+        return /(?:^|\n)\s*-?\s*name:\s*["']?scalemax(?:-(?:codex|claude))?["']?\s*(?:#.*)?(?:\n|$)/i.test(text);
     if (id === 'opencode' || id === 'openclaw') {
         try {
             const config = JSON.parse(text);
             return id === 'opencode'
                 ? config?.provider?.scalemax?.name === 'ScaleMax'
-                : typeof config?.models?.providers?.scalemax?.baseUrl === 'string';
+                : ['scalemax', 'scalemax-codex', 'scalemax-claude'].some(provider => typeof config?.models?.providers?.[provider]?.baseUrl === 'string');
         }
         catch {
             return false;

package/dist/detect/roo-code.d.ts

@@ -0,0 +1,2 @@
+import { DetectContext, DetectionResult } from '../types/client.js';
+export declare function detect(ctx: DetectContext): Promise<DetectionResult>;

package/dist/detect/roo-code.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import JSON5 from 'json5';
+import { commandExists } from '../utils/exec.js';
+import { clientConfigPath } from '../configure/paths.js';
+const extensionPattern = /^rooveterinaryinc\.roo-cline-/i;
+async function extensionPaths(home) {
+    const roots = [path.join(home, '.vscode', 'extensions'), path.join(home, '.vscode-insiders', 'extensions')];
+    const hits = [];
+    for (const root of roots) {
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries)
+            if (entry.isDirectory() && extensionPattern.test(entry.name))
+                hits.push(path.join(root, entry.name));
+    }
+    return hits;
+}
+export async function detect(ctx) {
+    const paths = await extensionPaths(ctx.home);
+    const executable = await commandExists('code', ctx.env);
+    if (executable)
+        paths.unshift('command:code');
+    const settingsPath = clientConfigPath('roo-code', ctx.home, ctx.platform, ctx.env);
+    let configured = false;
+    if (await fs.pathExists(settingsPath)) {
+        try {
+            const settings = JSON5.parse(await fs.readFile(settingsPath, 'utf8'));
+            configured = settings?.['roo-cline.autoImportSettingsPath'] === '~/.scalemax/roo-code-import.json';
+            if (configured)
+                paths.push(settingsPath);
+        }
+        catch { }
+    }
+    const installed = paths.some(entry => entry === 'command:code' || extensionPattern.test(path.basename(entry)));
+    return { id: 'roo-code', name: 'Roo Code (VS Code)', installed, configured, executable, reason: installed ? undefined : 'Roo Code extension was not detected', paths };
+}

package/dist/types/client.d.ts

@@ -1,4 +1,4 @@
-export type ClientId = 'codex' | 'cursor' | 'trae-solo' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'cherry-studio' | 'api-code';
+export type ClientId = 'codex' | 'cursor' | 'roo-code' | 'trae-solo' | 'claude' | 'opencode' | 'openclaw' | 'hermes' | 'cherry-studio' | 'api-code';
 export type ProviderScope = 'openai' | 'anthropic' | 'both';
 export interface ClientDefinition {
     id: ClientId;

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.18",
+  "version": "0.1.20",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {