scalemax 0.1.17 → 0.1.19

package/README.md

@@ -17,6 +17,8 @@ It detects supported AI coding clients, safely backs up existing config files, a
 - A ScaleMax API key
 - Network access to `https://api.scalemax.pro`
 
+The CLI identifies whether the supplied key belongs to the API-credit surface or the token-pack surface. It then stores and configures the matching base URL automatically; users do not need to choose it manually.
+
 ## Installation
 
 ### One-time run with npx
@@ -102,6 +104,7 @@ SCALEMAX_API_KEY=sm_live_xxx scalemax models
 
 - Codex
 - Cursor
+- Roo Code (VS Code)
 - TRAE SOLO
 - Claude Code
 - OpenCode
@@ -112,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
 
@@ -279,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.
 
@@ -313,4 +324,4 @@ Yes. The CLI uses Windows-aware config paths and writes `%APPDATA%\scalemax\conf
 
 ### What endpoint does it configure?
 
-OpenAI-compatible clients use `https://api.scalemax.pro/v1`. Anthropic-compatible clients such as Claude Code and OpenClaw use the origin `https://api.scalemax.pro`, because those clients append `/v1/messages` themselves.
+API-credit keys use `https://api.scalemax.pro/v1` for OpenAI-compatible clients and `https://api.scalemax.pro` for Anthropic-compatible clients. Token-pack keys use `https://api.scalemax.pro/token/v1` and `https://api.scalemax.pro/token` respectively. The CLI detects the key type and configures the correct surface automatically; the two key types are intentionally not interchangeable.

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

@@ -18,7 +18,7 @@ export async function printDetected(home = homeDir()) {
     console.log('');
     return detections;
 }
-async function maybeLaunchCodex(chosen, successful) {
+async function maybeLaunchCodex(chosen, successful, baseUrl = SCALEMAX_BASE_URL) {
     if (!chosen.includes('codex') || !successful.has('codex'))
         return;
     console.log(chalk.green('\nConfiguration completed.\n'));
@@ -31,7 +31,7 @@ async function maybeLaunchCodex(chosen, successful) {
         const apiKey = await loadApiKey(homeDir());
         if (!apiKey)
             throw new Error('No API key found.');
-        const result = await codex?.launch?.({ home: homeDir(), platform: process.platform, env: process.env, apiKey, baseUrl: SCALEMAX_BASE_URL });
+        const result = await codex?.launch?.({ home: homeDir(), platform: process.platform, env: process.env, apiKey, baseUrl });
         console.log(chalk.green(`✓ ${result?.message || 'Codex launched.'}`));
     }
     catch (err) {
@@ -42,7 +42,7 @@ async function maybeLaunchCodex(chosen, successful) {
 export function clientAllowedForModels(clientId, models) {
     if (!models.length)
         return false;
-    const crossProtocolClients = new Set(['claude', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const crossProtocolClients = new Set(['claude', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
     if (crossProtocolClients.has(clientId))
         return true;
     return models.some(model => !isAnthropicModel(model));
@@ -61,6 +61,7 @@ export async function configureCommand(opts = {}) {
     if (!keyInfo.models.length)
         throw new Error(keyInfo.error || 'ScaleMax returned no models for this API key. No client configuration was changed.');
     const providerScope = keyInfo.key?.provider_scope || 'both';
+    const selectedBaseUrl = keyInfo.baseUrl || SCALEMAX_BASE_URL;
     const availableClients = clients.filter(c => clientAllowedForModels(c.id, keyInfo.models));
     console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Clients are filtered against the authenticated model catalog.`));
     const detections = await printDetected(home);
@@ -119,7 +120,7 @@ export async function configureCommand(opts = {}) {
         }
         const spinner = ora(`Configuring ${client.name}`).start();
         try {
-            const ctx = { ...baseCtx, apiKey, baseUrl: SCALEMAX_BASE_URL, providerScope, models: keyInfo.models, interactive: Boolean(process.stdin.isTTY), allowAppModification };
+            const ctx = { ...baseCtx, apiKey, baseUrl: selectedBaseUrl, providerScope, models: keyInfo.models, interactive: Boolean(process.stdin.isTTY), allowAppModification };
             const res = await client.configure(ctx);
             spinner.succeed(`${client.name} ${res.message}`);
             if (client.verify) {
@@ -148,7 +149,7 @@ export async function configureCommand(opts = {}) {
         }
     }
     if (opts.promptLaunch !== false && !opts.all && process.stdin.isTTY)
-        await maybeLaunchCodex(chosen, successful);
+        await maybeLaunchCodex(chosen, successful, selectedBaseUrl);
     if (failures.length)
         throw new Error(`${failures.length} client configuration(s) failed:\n${failures.map(f => `- ${f}`).join('\n')}`);
 }

package/dist/commands/doctor.js

@@ -22,7 +22,7 @@ export async function doctorCommand(home = homeDir()) {
             s.succeed(`API reachable, key valid, ${models.length} models loaded`);
             console.log(`${chalk.green('✓')} Usage and key metadata accessible through the authenticated API`);
             const st = ora('Checking streaming (small billable request)').start();
-            const stream = await testStreaming(key, models.find(m => m.id === 'fable-5')?.id || models[0]?.id);
+            const stream = await testStreaming(key, models.find(m => m.id === 'fable-5')?.id || models[0]?.id, res.baseUrl);
             if (stream.ok)
                 st.succeed('Streaming available');
             else {
@@ -49,7 +49,8 @@ export async function doctorCommand(home = homeDir()) {
         }
         if (client.verify && key && models.length) {
             try {
-                const v = await client.verify({ home, platform: process.platform, env: process.env, apiKey: key, baseUrl: SCALEMAX_BASE_URL, models });
+                const checked = await validateApiKey(key);
+                const v = await client.verify({ home, platform: process.platform, env: process.env, apiKey: key, baseUrl: checked.baseUrl || SCALEMAX_BASE_URL, models });
                 console.log(`${chalk.green('✓')} ${client.name} ${v.message}`);
             }
             catch (error) {

package/dist/commands/login.js

@@ -3,7 +3,6 @@ import ora from 'ora';
 import chalk from 'chalk';
 import { validateApiKey } from '../utils/api.js';
 import { saveApiKey } from '../utils/keyStore.js';
-import { SCALEMAX_BASE_URL } from '../constants.js';
 import { homeDir } from '../utils/paths.js';
 import { sanitizeApiKey } from '../utils/apiKey.js';
 export async function loginCommand(home = homeDir()) {
@@ -20,7 +19,7 @@ export async function loginCommand(home = homeDir()) {
         spinner.fail('Invalid API Key');
         throw new Error(result.error || 'Invalid API Key');
     }
-    await saveApiKey(sanitizedKey, SCALEMAX_BASE_URL, home);
+    await saveApiKey(sanitizedKey, result.baseUrl, home);
     spinner.succeed(`API Key verified (${result.key?.provider_scope || 'both'} provider scope)`);
     outro(chalk.green('ScaleMax API key saved.'));
     return sanitizedKey;

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,12 @@
 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;
 export declare function preferredModel(ctx: ConfigureContext): string;
 export declare function fastModel(ctx: ConfigureContext): string | undefined;
+export declare function fastOpenAiModel(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,49 @@
-const preferred = [
+import { isAnthropicModel } 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.6-sol',
+    'gpt-5.5',
+    'gpt-5.4',
+    'gpt-5.4-mini',
+    'gpt-5.3-codex',
     'fable-5',
-    'fable-5-ultra'
+    'fable-5-ultra',
+    'codex-auto-review'
 ];
 export function modelIds(ctx) {
     return [...new Set((ctx.models || []).map(model => model.id.trim()).filter(Boolean))];
 }
+export function anthropicModelIds(ctx) {
+    return [...new Set((ctx.models || []).filter(isAnthropicModel).map(model => model.id.trim()).filter(Boolean))];
+}
+export function openAiModelIds(ctx) {
+    return [...new Set((ctx.models || []).filter(model => !isAnthropicModel(model)).map(model => model.id.trim()).filter(Boolean))];
+}
+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');
+}
 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 +55,11 @@ 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));
+}
 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 { fastOpenAiModel, modelName, openAiBaseUrl, openAiModelIds, preferredOpenAiModel } 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(modelIds(ctx).map(modelId => {
+    const models = Object.fromEntries(openAiModelIds(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/${preferredModel(ctx)}`;
-    const quick = fastModel(ctx);
+    const selected = `scalemax/${preferredOpenAiModel(ctx)}`;
+    const quick = fastOpenAiModel(ctx);
     const secret = await writeClientSecret(secretPath(ctx.home), ctx);
     let result;
     try {
@@ -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 = openAiModelIds(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).`);
     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,119 @@
+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, openAiModelIds, preferredOpenAiModel } from './models.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';
+function importPath(home) { return path.join(home, '.scalemax', 'roo-code-import.json'); }
+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 selected = preferredOpenAiModel(ctx);
+    return JSON.stringify({
+        providerProfiles: {
+            currentApiConfigName: profileName,
+            apiConfigs: {
+                [profileName]: {
+                    id: profileId,
+                    apiProvider: 'openai',
+                    openAiBaseUrl: openAiBaseUrl(ctx.baseUrl),
+                    openAiApiKey: ctx.apiKey,
+                    openAiModelId: selected,
+                    openAiStreamingEnabled: true,
+                    includeMaxTokens: true
+                }
+            },
+            modeApiConfigs: {}
+        },
+        globalSettings: {}
+    }, 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(() => '');
+    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 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
+        || 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);
+        if (profile?.providerProfiles?.apiConfigs?.[profileName]?.id === profileId) {
+            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/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const SCALEMAX_BASE_URL = "https://api.scalemax.pro/v1";
+export declare const SCALEMAX_TOKEN_BASE_URL = "https://api.scalemax.pro/token/v1";
 export declare const APP_NAME = "ScaleMax";
 export declare const GENERATED_HEADER = "ScaleMax managed configuration";
 export declare const KEY_ENV = "SCALEMAX_API_KEY";

package/dist/constants.js

@@ -1,4 +1,5 @@
 export const SCALEMAX_BASE_URL = 'https://api.scalemax.pro/v1';
+export const SCALEMAX_TOKEN_BASE_URL = 'https://api.scalemax.pro/token/v1';
 export const APP_NAME = 'ScaleMax';
 export const GENERATED_HEADER = 'ScaleMax managed configuration';
 export const KEY_ENV = 'SCALEMAX_API_KEY';

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

@@ -14,15 +14,18 @@ export interface KeyMetadata {
     prefix?: string;
     label?: string;
 }
-export declare function isAnthropicModel(model: ModelInfo): boolean;
-export declare function filterModelsForScope(models: ModelInfo[], scope: ProviderScope): ModelInfo[];
-export declare function validateApiKey(apiKey: string): Promise<{
+export interface ApiValidation {
     ok: boolean;
     models: ModelInfo[];
     key?: KeyMetadata;
+    baseUrl?: string;
     error?: string;
-}>;
-export declare function testStreaming(apiKey: string, model?: string): Promise<{
+    surfaceMismatch?: 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>;
+export declare function testStreaming(apiKey: string, model?: string, baseUrl?: string): Promise<{
     ok: boolean;
     error?: string;
 }>;

package/dist/utils/api.js

@@ -1,4 +1,4 @@
-import { SCALEMAX_BASE_URL } from '../constants.js';
+import { SCALEMAX_BASE_URL, SCALEMAX_TOKEN_BASE_URL } from '../constants.js';
 import { redactApiKey, sanitizeApiKey } from './apiKey.js';
 export function isAnthropicModel(model) {
     const provider = String(model.provider || model.owned_by || '').trim().toLowerCase();
@@ -34,7 +34,7 @@ async function friendlyError(res) {
 function retryableStatus(status) {
     return status === 408 || status === 429 || status >= 500;
 }
-async function request(path, apiKey, init = {}, retryGet = false) {
+async function request(path, apiKey, init = {}, retryGet = false, baseUrl = SCALEMAX_BASE_URL) {
     const headers = new Headers(init.headers);
     if (apiKey)
         headers.set('Authorization', `Bearer ${sanitizeApiKey(apiKey)}`);
@@ -47,7 +47,7 @@ async function request(path, apiKey, init = {}, retryGet = false) {
         const timeout = AbortSignal.timeout(15000);
         const signal = init.signal && typeof AbortSignal.any === 'function' ? AbortSignal.any([init.signal, timeout]) : timeout;
         try {
-            const response = await fetch(`${SCALEMAX_BASE_URL}${path}`, { ...init, headers, signal });
+            const response = await fetch(`${baseUrl}${path}`, { ...init, headers, signal });
             if (attempt + 1 === attempts || !retryableStatus(response.status))
                 return response;
             await response.body?.cancel().catch(() => undefined);
@@ -61,14 +61,14 @@ async function request(path, apiKey, init = {}, retryGet = false) {
     }
     throw lastError;
 }
-export async function validateApiKey(apiKey) {
+async function validateOnSurface(apiKey, baseUrl) {
     try {
         const [authCheck, modelsRes] = await Promise.all([
-            request('/usage', apiKey, {}, true),
-            request('/models', apiKey, {}, true)
+            request('/usage', apiKey, {}, true, baseUrl),
+            request('/models', apiKey, {}, true, baseUrl)
         ]);
         if (!authCheck.ok)
-            return { ok: false, models: [], error: redactApiKey(await friendlyError(authCheck), apiKey) };
+            return { ok: false, models: [], error: redactApiKey(await friendlyError(authCheck), apiKey), surfaceMismatch: authCheck.status === 401 };
         const usage = await authCheck.json().catch(() => ({}));
         const keyMeta = { provider_scope: usage?.key?.provider_scope || 'both', mode: usage?.key?.mode, prefix: usage?.key?.prefix, label: usage?.key?.label };
         if (!modelsRes.ok)
@@ -78,17 +78,28 @@ export async function validateApiKey(apiKey) {
         const models = filterModelsForScope(catalog, keyMeta.provider_scope);
         if (!models.length)
             return { ok: false, models: [], key: keyMeta, error: 'ScaleMax returned an empty model catalog.' };
-        return { ok: true, models, key: keyMeta };
+        return { ok: true, models, key: keyMeta, baseUrl };
     }
     catch (err) {
         const message = redactApiKey(err instanceof Error ? err.message : String(err), apiKey);
         return { ok: false, models: [], error: /abort|timeout/i.test(message) ? 'ScaleMax request timed out after 15 seconds.' : message };
     }
 }
-export async function testStreaming(apiKey, model) {
+export async function validateApiKey(apiKey) {
+    const credit = await validateOnSurface(apiKey, SCALEMAX_BASE_URL);
+    if (credit.ok)
+        return credit;
+    if (!credit.surfaceMismatch)
+        return credit;
+    const token = await validateOnSurface(apiKey, SCALEMAX_TOKEN_BASE_URL);
+    if (token.ok)
+        return token;
+    return credit.error && !/Invalid API key|rejected|401/i.test(credit.error) ? credit : token;
+}
+export async function testStreaming(apiKey, model, baseUrl = SCALEMAX_BASE_URL) {
     const selected = model || 'fable-5';
     try {
-        const res = await request('/chat/completions', apiKey, { method: 'POST', body: JSON.stringify({ model: selected, stream: true, max_tokens: 8, messages: [{ role: 'user', content: 'Say OK' }] }) });
+        const res = await request('/chat/completions', apiKey, { method: 'POST', body: JSON.stringify({ model: selected, stream: true, max_tokens: 8, messages: [{ role: 'user', content: 'Say OK' }] }) }, false, baseUrl);
         if (!res.ok)
             return { ok: false, error: redactApiKey(await friendlyError(res), apiKey) };
         const ct = res.headers.get('content-type') || '';

package/dist/utils/installerConfig.js

@@ -1,7 +1,7 @@
 import { intro, outro, password, select, confirm, isCancel, cancel } from '@clack/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
-import { KEY_ENV, SCALEMAX_BASE_URL } from '../constants.js';
+import { KEY_ENV } from '../constants.js';
 import { validateApiKey } from './api.js';
 import { loadApiKey, removeApiKey, saveApiKey } from './keyStore.js';
 import { homeDir } from './paths.js';
@@ -25,7 +25,7 @@ export async function promptForValidatedKey(home, message = 'Enter your ScaleMax
         spinner.fail('Invalid API key');
         throw new Error(result.error || 'Invalid API key');
     }
-    await saveApiKey(candidate, SCALEMAX_BASE_URL, home);
+    await saveApiKey(candidate, result.baseUrl, home);
     spinner.succeed('API key verified and saved');
     return candidate;
 }

package/dist/utils/keyStore.d.ts

@@ -1,3 +1,4 @@
 export declare function saveApiKey(apiKey: string, baseUrl: string, home: string): Promise<void>;
 export declare function loadApiKey(home: string): Promise<string | undefined>;
+export declare function loadBaseUrl(home: string): Promise<string | undefined>;
 export declare function removeApiKey(home: string): Promise<void>;

package/dist/utils/keyStore.js

@@ -13,6 +13,10 @@ export async function loadApiKey(home) {
     const cfg = await readJson(scaleMaxConfigPath(home), {});
     return cfg.apiKey ? sanitizeApiKey(cfg.apiKey) : undefined;
 }
+export async function loadBaseUrl(home) {
+    const cfg = await readJson(scaleMaxConfigPath(home), {});
+    return cfg.baseUrl;
+}
 export async function removeApiKey(home) {
     await fs.remove(scaleMaxConfigPath(home));
 }

package/package.json

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