scalemax 0.1.14 → 0.1.15

package/README.md

@@ -1,6 +1,6 @@
 # ScaleMax CLI
 
-Universal installer for configuring AI coding clients to use the ScaleMax OpenAI-compatible API gateway.
+Universal installer for configuring AI coding clients to use the ScaleMax OpenAI- and Anthropic-compatible API gateway.
 
 ScaleMax CLI is designed to be run from any machine with Node.js installed:
 
@@ -98,7 +98,7 @@ SCALEMAX_API_KEY=sm_live_xxx scalemax models
 
 ## Supported clients
 
-`npx scalemax` supports this client set:
+`scalemax` supports this client set whether it is run through a global install or with `npx`:
 
 - Codex
 - Cursor
@@ -114,7 +114,19 @@ For clients without a stable official config file, the installer writes a ScaleM
 
 ### Claude Code
 
-ScaleMax configures Claude Code with the Anthropic-compatible origin `https://api.scalemax.pro`, preserves unrelated settings and environment variables, and selects a live `claude-*` model from the authenticated model catalog (preferring `claude-opus-4-8`). It verifies `/v1/messages` after setup and rolls back managed changes if verification fails. Claude Code picker aliases such as `claude-opus-4-8[1m]` are normalized by the ScaleMax gateway.
+ScaleMax updates `~/.claude/settings.json` with `ANTHROPIC_BASE_URL=https://api.scalemax.pro`, the stored key as `ANTHROPIC_AUTH_TOKEN`, and gateway model discovery. The Anthropic base URL intentionally has no `/v1` suffix because Claude Code adds `/v1/messages` itself. The CLI preserves unrelated settings, selects a live model from the authenticated catalog (preferring `claude-opus-4-8`), and verifies a one-token Messages request. If verification fails, it 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`, keeps unrelated providers and the user's non-ScaleMax default model, and loads every model available to the authenticated key. 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`. It adds every authenticated model to the provider and agent allowlist, caps generated output limits at 4096 tokens, and preserves unrelated providers and agent settings. Legacy ScaleMax artifacts are removed only when they carry the ScaleMax managed marker.
+
+### 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.
 
 ### Cursor BYOK routing on macOS
 
@@ -296,4 +308,4 @@ Yes. The CLI uses Windows-aware config paths and writes `%APPDATA%\scalemax\conf
 
 ### What endpoint does it configure?
 
-`https://api.scalemax.pro/v1`
+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.

package/dist/clients.js

@@ -21,9 +21,9 @@ export const clients = [
     { id: 'cursor', name: 'Cursor', detect: cursorDetect.detect, configure: cursorConfig.configure, verify: cursorConfig.verify, remove: cursorConfig.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, remove: opencodeConfig.remove },
-    { id: 'openclaw', name: 'OpenClaw', detect: openclawDetect.detect, configure: openclawConfig.configure, remove: openclawConfig.remove },
-    { id: 'hermes', name: 'Hermes', detect: hermesDetect.detect, configure: hermesConfig.configure, remove: hermesConfig.remove },
+    { id: 'opencode', name: 'OpenCode', detect: opencodeDetect.detect, configure: opencodeConfig.configure, verify: opencodeConfig.verify, remove: opencodeConfig.remove },
+    { id: 'openclaw', name: 'OpenClaw', detect: openclawDetect.detect, configure: openclawConfig.configure, verify: openclawConfig.verify, remove: openclawConfig.remove },
+    { id: 'hermes', name: 'Hermes', detect: hermesDetect.detect, configure: hermesConfig.configure, verify: hermesConfig.verify, remove: hermesConfig.remove },
     { id: 'cherry-studio', name: 'Cherry Studio', detect: cherryStudioDetect.detect, configure: cherryStudioConfig.configure, remove: cherryStudioConfig.remove },
     { id: 'api-code', name: 'API Code', detect: apiCodeDetect.detect, configure: apiCodeConfig.configure, remove: apiCodeConfig.remove }
 ];

package/dist/commands/configure.d.ts

@@ -1,5 +1,8 @@
+import { ModelInfo } from '../utils/api.js';
+import { ClientId } from '../types/client.js';
 export declare function detectAll(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
 export declare function printDetected(home?: string): Promise<import("../types/client.js").DetectionResult[]>;
+export declare function clientAllowedForModels(clientId: ClientId, models: ModelInfo[]): boolean;
 export declare function configureCommand(opts?: {
     all?: boolean;
     home?: string;

package/dist/commands/configure.js

@@ -4,7 +4,7 @@ import ora from 'ora';
 import { clients } from '../clients.js';
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
-import { validateApiKey } from '../utils/api.js';
+import { validateApiKey, isAnthropicModel } from '../utils/api.js';
 import { homeDir } from '../utils/paths.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
@@ -39,14 +39,13 @@ async function maybeLaunchCodex(chosen, successful) {
     }
     console.log('\nIf Codex asks for authentication,\nit should already be configured to use ScaleMax.\n\nIf you still see the official login screen,\nthe configuration is incomplete or Codex rejected the generated auth/config files.\n');
 }
-function clientAllowedForScope(clientId, scope) {
-    if (scope === 'both')
+export function clientAllowedForModels(clientId, models) {
+    if (!models.length)
+        return false;
+    const crossProtocolClients = new Set(['claude', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    if (crossProtocolClients.has(clientId))
         return true;
-    if (clientId === 'claude')
-        return scope === 'anthropic';
-    if (clientId === 'api-code')
-        return true;
-    return scope === 'openai';
+    return models.some(model => !isAnthropicModel(model));
 }
 function scopeHint(scope) {
     return scope === 'both' ? 'OpenAI + Claude' : scope === 'anthropic' ? 'Claude only' : 'OpenAI only';
@@ -62,8 +61,8 @@ 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 availableClients = clients.filter(c => clientAllowedForScope(c.id, providerScope));
-    console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Incompatible clients are hidden.`));
+    const availableClients = clients.filter(c => clientAllowedForModels(c.id, keyInfo.models));
+    console.log(chalk.dim(`API key scope: ${scopeHint(providerScope)}. Clients are filtered against the authenticated model catalog.`));
     const detections = await printDetected(home);
     const detectedIds = new Set(detections.filter(d => d.installed).map(d => d.id));
     let chosen;

package/dist/configure/claude.js

@@ -1,27 +1,63 @@
+import fs from 'fs-extra';
+import crypto from 'node:crypto';
+import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
-import { writeMergedJsonConfig, removeManagedConfig } from './common.js';
+import { writeMergedJsonConfig } from './common.js';
 import { GENERATED_HEADER } from '../constants.js';
-import fs from 'fs-extra';
-const id = 'claude', name = 'Claude Code';
-function claudeModel(ctx) { const ids = (ctx.models || []).map(m => m.id).filter(x => x.startsWith('claude-')); for (const preferred of ['claude-opus-4-8', 'claude-sonnet-5', 'claude-opus-4-7', 'claude-opus-4-6', 'claude-haiku-4-5-20251001'])
-    if (ids.includes(preferred))
-        return preferred; if (ids.length)
-    return ids[0]; throw new Error('No Claude models are available for this API key; Claude Code was not changed.'); }
-function anthropicOrigin(baseUrl) { const url = new URL(baseUrl); url.pathname = url.pathname.replace(/\/v1\/?$/, '').replace(/\/$/, ''); url.search = ''; url.hash = ''; return url.toString().replace(/\/$/, ''); }
+import { anthropicOrigin, modelIds, preferredModel } from './models.js';
+const id = 'claude';
+const name = 'Claude Code';
+const discoveryKey = 'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY';
+const managedEnvKeys = ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_MODEL', discoveryKey];
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
 export async function configure(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform), model = claudeModel(ctx);
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const model = preferredModel(ctx);
+    const baseUrl = anthropicOrigin(ctx.baseUrl);
     const result = await writeMergedJsonConfig(ctx, id, name, file, existing => {
-        const env = existing.env && typeof existing.env === 'object' && !Array.isArray(existing.env) ? existing.env : {};
-        return JSON.stringify({ ...existing, env: { ...env, ANTHROPIC_AUTH_TOKEN: ctx.apiKey, ANTHROPIC_BASE_URL: anthropicOrigin(ctx.baseUrl), ANTHROPIC_MODEL: model }, 'scalemax.managedBy': GENERATED_HEADER, scalemax: { managedBy: 'ScaleMax CLI', anthropicModel: model } }, null, 2) + '\n';
+        const env = asRecord(existing.env);
+        const oldMetadata = asRecord(existing.scalemax);
+        const previousEnv = oldMetadata.managedBy === 'ScaleMax CLI'
+            ? asRecord(oldMetadata.previousEnv)
+            : Object.fromEntries(managedEnvKeys.filter(key => Object.prototype.hasOwnProperty.call(env, key)).map(key => [key, env[key]]));
+        return JSON.stringify({
+            ...existing,
+            env: {
+                ...env,
+                ANTHROPIC_AUTH_TOKEN: ctx.apiKey,
+                ANTHROPIC_BASE_URL: baseUrl,
+                ANTHROPIC_MODEL: model,
+                [discoveryKey]: '1'
+            },
+            'scalemax.managedBy': GENERATED_HEADER,
+            scalemax: {
+                managedBy: 'ScaleMax CLI',
+                anthropicModel: model,
+                anthropicBaseUrl: baseUrl,
+                gatewayDiscovery: '1',
+                authTokenSha256: crypto.createHash('sha256').update(ctx.apiKey).digest('hex'),
+                previousEnv
+            }
+        }, null, 2) + '\n';
     });
-    return { ...result, message: `configured Anthropic-compatible routing with ${model}` };
+    return { ...result, message: `configured Anthropic Messages routing with ${model} and gateway model discovery` };
 }
 export async function verify(ctx) {
-    const file = clientConfigPath(id, ctx.home, ctx.platform), settings = await fs.readJson(file);
-    const env = settings?.env || {}, model = String(env.ANTHROPIC_MODEL || '');
-    if (!model.startsWith('claude-') || env.ANTHROPIC_BASE_URL !== anthropicOrigin(ctx.baseUrl) || env.ANTHROPIC_AUTH_TOKEN !== ctx.apiKey)
-        throw new Error('Claude Code settings do not match the authenticated ScaleMax configuration.');
-    const response = await fetch(`${anthropicOrigin(ctx.baseUrl)}/v1/messages`, { method: 'POST', headers: { Authorization: `Bearer ${ctx.apiKey}`, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' }, body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'Reply OK' }] }), signal: AbortSignal.timeout(15000) });
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const settings = await fs.readJson(file);
+    const env = asRecord(settings?.env);
+    const model = String(env.ANTHROPIC_MODEL || '');
+    if (!modelIds(ctx).includes(model) || env.ANTHROPIC_BASE_URL !== anthropicOrigin(ctx.baseUrl) || env.ANTHROPIC_AUTH_TOKEN !== ctx.apiKey || env[discoveryKey] !== '1') {
+        throw new Error('Claude Code settings do not match the authenticated ScaleMax model catalog.');
+    }
+    const response = await fetch(`${anthropicOrigin(ctx.baseUrl)}/v1/messages`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${ctx.apiKey}`, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
+        body: JSON.stringify({ model, max_tokens: 1, stream: false, messages: [{ role: 'user', content: 'K' }] }),
+        signal: AbortSignal.timeout(15000)
+    });
     if (!response.ok) {
         let message = `HTTP ${response.status}`;
         try {
@@ -33,4 +69,40 @@ export async function verify(ctx) {
     }
     return { id, name, changed: false, path: file, message: `verified Anthropic Messages with ${model}` };
 }
-export async function remove(ctx) { return removeManagedConfig(ctx, id, name, clientConfigPath(id, ctx.home, ctx.platform)); }
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    if (!(await fs.pathExists(file)))
+        return { id, name, changed: false, path: file, message: 'no ScaleMax configuration found' };
+    const settings = await fs.readJson(file).catch(() => undefined);
+    if (!settings || settings?.scalemax?.managedBy !== 'ScaleMax CLI')
+        return { id, name, changed: false, path: file, message: 'left unmanaged configuration unchanged' };
+    const managed = asRecord(settings.scalemax);
+    const env = asRecord(settings.env);
+    const previous = asRecord(managed.previousEnv);
+    const restore = (key) => {
+        if (Object.prototype.hasOwnProperty.call(previous, key))
+            env[key] = previous[key];
+        else
+            delete env[key];
+    };
+    if (env.ANTHROPIC_BASE_URL === managed.anthropicBaseUrl)
+        restore('ANTHROPIC_BASE_URL');
+    if (env.ANTHROPIC_MODEL === managed.anthropicModel)
+        restore('ANTHROPIC_MODEL');
+    if (env[discoveryKey] === managed.gatewayDiscovery)
+        restore(discoveryKey);
+    if (typeof env.ANTHROPIC_AUTH_TOKEN === 'string' && crypto.createHash('sha256').update(env.ANTHROPIC_AUTH_TOKEN).digest('hex') === managed.authTokenSha256)
+        restore('ANTHROPIC_AUTH_TOKEN');
+    if (Object.keys(env).length)
+        settings.env = env;
+    else
+        delete settings.env;
+    delete settings['scalemax.managedBy'];
+    delete settings.scalemax;
+    await backupFile(file, ctx.home);
+    if (Object.keys(settings).length)
+        await atomicWrite(file, JSON.stringify(settings, null, 2) + '\n', 0o600, ctx.platform);
+    else
+        await fs.remove(file);
+    return { id, name, changed: true, path: file, message: 'removed only ScaleMax Claude Code settings' };
+}

package/dist/configure/hermes.d.ts

@@ -1,3 +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/hermes.js

@@ -1,14 +1,156 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { parseDocument } from 'yaml';
+import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
-import { writeManagedConfig, removeManagedConfig } from './common.js';
-import { jsonConfig } from './templates.js';
+import { isScaleMaxManagedText } from './common.js';
+import { modelIds, openAiBaseUrl, preferredModel } from './models.js';
 const id = 'hermes';
 const name = 'Hermes';
+const envKey = 'SCALEMAX_HERMES_API_KEY';
+const envMarker = '# ScaleMax managed Hermes API key';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function envPath(home) { return path.join(home, '.hermes', '.env'); }
+function managedEnv(text, apiKey) {
+    const kept = text.split(/\r?\n/).filter(line => line.trim() !== envMarker && !line.startsWith(`${envKey}=`));
+    while (kept.length && !kept[kept.length - 1])
+        kept.pop();
+    return `${kept.length ? `${kept.join('\n')}\n` : ''}${envMarker}\n${envKey}=${apiKey}\n`;
+}
+function withoutManagedEnv(text) {
+    const kept = text.split(/\r?\n/).filter(line => line.trim() !== envMarker && !line.startsWith(`${envKey}=`));
+    while (kept.length && !kept[kept.length - 1])
+        kept.pop();
+    return kept.length ? `${kept.join('\n')}\n` : '';
+}
+function parseYaml(text) {
+    const doc = parseDocument(text || '{}');
+    if (doc.errors.length)
+        throw new Error(`Hermes config.yaml is invalid: ${doc.errors[0].message}`);
+    if (!doc.contents)
+        doc.contents = doc.createNode({});
+    return doc;
+}
+function modelMetadata(ctx) {
+    return Object.fromEntries(modelIds(ctx).map(modelId => {
+        const model = (ctx.models || []).find(candidate => candidate.id === modelId);
+        const metadata = {};
+        if (model?.context_window)
+            metadata.context_length = model.context_window;
+        return [modelId, metadata];
+    }));
+}
+async function removeLegacyArtifact(ctx) {
+    const legacy = path.join(ctx.home, '.hermes', 'config', 'scalemax.json');
+    if (!(await fs.pathExists(legacy)))
+        return;
+    const text = await fs.readFile(legacy, 'utf8').catch(() => '');
+    if (!isScaleMaxManagedText(text) || !text.includes('api.scalemax.pro'))
+        return;
+    await backupFile(legacy, ctx.home);
+    await fs.remove(legacy);
+}
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl);
-    return writeManagedConfig(ctx, id, name, file, content);
+    const secrets = envPath(ctx.home);
+    await fs.ensureDir(path.dirname(file));
+    const originalConfig = await fs.readFile(file, 'utf8').catch(() => '');
+    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)
+    });
+    doc.set('custom_providers', providers);
+    const currentModel = asRecord(data.model);
+    const activatesScaleMax = !currentModel.provider || String(currentModel.provider).startsWith('custom:scalemax');
+    if (activatesScaleMax) {
+        doc.set('model', { ...currentModel, provider: 'custom:scalemax', default: preferredModel(ctx), max_tokens: 4096 });
+    }
+    const backups = [await backupFile(file, ctx.home), await backupFile(secrets, ctx.home)].filter(Boolean);
+    try {
+        await atomicWrite(file, String(doc), 0o600, ctx.platform);
+        await atomicWrite(secrets, managedEnv(originalEnv, ctx.apiKey), 0o600, ctx.platform);
+        await removeLegacyArtifact(ctx);
+    }
+    catch (error) {
+        if (originalConfig)
+            await atomicWrite(file, originalConfig, 0o600, ctx.platform);
+        else
+            await fs.remove(file).catch(() => undefined);
+        if (originalEnv)
+            await atomicWrite(secrets, originalEnv, 0o600, ctx.platform);
+        else
+            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)' : ''}` };
+}
+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 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}`))
+        throw new Error('Hermes is missing authenticated ScaleMax models or credentials.');
+    if (data?.model?.provider === '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` };
 }
 export async function remove(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    return removeManagedConfig(ctx, id, name, file);
+    const secrets = envPath(ctx.home);
+    if (!(await fs.pathExists(file)))
+        return { id, name, changed: false, path: file, message: 'no ScaleMax configuration found' };
+    const text = await fs.readFile(file, 'utf8');
+    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)
+        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');
+    if (remaining.length)
+        doc.set('custom_providers', remaining);
+    else
+        doc.delete('custom_providers');
+    if (data?.model?.provider === 'custom:scalemax')
+        doc.deleteIn(['model', 'provider']);
+    if (data?.model?.provider === 'custom:scalemax' && managedModels.includes(String(data?.model?.default || '')))
+        doc.deleteIn(['model', 'default']);
+    if (data?.model?.provider === 'custom:scalemax' && data?.model?.max_tokens === 4096)
+        doc.deleteIn(['model', 'max_tokens']);
+    const currentEnv = await fs.readFile(secrets, 'utf8').catch(() => '');
+    await backupFile(file, ctx.home);
+    if (currentEnv)
+        await backupFile(secrets, ctx.home);
+    const nextData = asRecord(doc.toJS());
+    if (Object.keys(nextData).length)
+        await atomicWrite(file, String(doc), 0o600, ctx.platform);
+    else
+        await fs.remove(file);
+    const nextEnv = withoutManagedEnv(currentEnv);
+    if (nextEnv)
+        await atomicWrite(secrets, nextEnv, 0o600, ctx.platform);
+    else
+        await fs.remove(secrets).catch(() => undefined);
+    await removeLegacyArtifact(ctx);
+    return { id, name, changed: true, path: file, message: 'removed only the ScaleMax custom provider and credential' };
 }

package/dist/configure/models.d.ts

@@ -0,0 +1,6 @@
+import { ConfigureContext } from '../types/client.js';
+export declare function modelIds(ctx: ConfigureContext): string[];
+export declare function preferredModel(ctx: ConfigureContext): string;
+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

@@ -0,0 +1,38 @@
+const preferred = [
+    'claude-opus-4-8',
+    'claude-sonnet-5',
+    'claude-opus-4-7',
+    'claude-opus-4-6',
+    'claude-haiku-4-5-20251001',
+    'fable-5',
+    'fable-5-ultra'
+];
+export function modelIds(ctx) {
+    return [...new Set((ctx.models || []).map(model => model.id.trim()).filter(Boolean))];
+}
+export function preferredModel(ctx) {
+    const ids = modelIds(ctx);
+    for (const candidate of preferred)
+        if (ids.includes(candidate))
+            return candidate;
+    if (ids.length)
+        return ids[0];
+    throw new Error('No compatible models are available for this API key; the client was not changed.');
+}
+export function modelName(ctx, id) {
+    const model = (ctx.models || []).find(candidate => candidate.id === id);
+    if (model?.display_name)
+        return model.display_name;
+    return id.split('-').map(part => part ? part[0].toUpperCase() + part.slice(1) : part).join(' ');
+}
+export function anthropicOrigin(baseUrl) {
+    const url = new URL(baseUrl);
+    url.pathname = url.pathname.replace(/\/v1\/?$/, '').replace(/\/$/, '');
+    url.search = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/, '');
+}
+export function openAiBaseUrl(baseUrl) {
+    const origin = anthropicOrigin(baseUrl);
+    return `${origin}/v1`;
+}

package/dist/configure/openclaw.d.ts

@@ -1,3 +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/openclaw.js

@@ -1,14 +1,129 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
-import { writeManagedConfig, removeManagedConfig } from './common.js';
-import { jsonConfig } from './templates.js';
+import { isScaleMaxManagedText, writeMergedJsonConfig } from './common.js';
+import { anthropicOrigin, modelIds, modelName, preferredModel } from './models.js';
 const id = 'openclaw';
 const name = 'OpenClaw';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function entries(ctx) {
+    return modelIds(ctx).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'],
+            maxTokens: Math.min(metadata?.max_output_tokens || 4096, 4096)
+        };
+        if (metadata?.context_window || modelId.startsWith('claude-'))
+            result.contextWindow = metadata?.context_window || 200000;
+        return result;
+    });
+}
+async function removeLegacyArtifact(ctx) {
+    const legacy = path.join(ctx.home, '.openclaw', 'config.json');
+    if (!(await fs.pathExists(legacy)))
+        return;
+    const text = await fs.readFile(legacy, 'utf8').catch(() => '');
+    if (!isScaleMaxManagedText(text) || !text.includes('api.scalemax.pro'))
+        return;
+    await backupFile(legacy, ctx.home);
+    await fs.remove(legacy);
+}
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = jsonConfig(name, ctx.apiKey, ctx.baseUrl);
-    return writeManagedConfig(ctx, id, name, file, content);
+    const primary = `scalemax/${preferredModel(ctx)}`;
+    const result = await writeMergedJsonConfig(ctx, id, name, file, existing => {
+        const modelsRoot = asRecord(existing.models);
+        const providers = asRecord(modelsRoot.providers);
+        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}`]);
+        const currentModel = defaults.model;
+        const currentPrimary = typeof currentModel === 'string' ? currentModel : asRecord(currentModel).primary;
+        const nextModel = !currentPrimary || String(currentPrimary).startsWith('scalemax/')
+            ? { ...asRecord(currentModel), primary }
+            : currentModel;
+        return JSON.stringify({
+            ...existing,
+            models: {
+                ...modelsRoot,
+                mode: modelsRoot.mode || 'merge',
+                providers: {
+                    ...providers,
+                    scalemax: {
+                        baseUrl: anthropicOrigin(ctx.baseUrl),
+                        apiKey: ctx.apiKey,
+                        api: 'anthropic-messages',
+                        maxTokens: 4096,
+                        models: entries(ctx)
+                    }
+                }
+            },
+            agents: {
+                ...agents,
+                defaults: { ...defaults, model: nextModel, models: allowlist }
+            }
+        }, null, 2) + '\n';
+    });
+    await removeLegacyArtifact(ctx);
+    return { ...result, message: `configured native Anthropic provider with ${modelIds(ctx).length} models` };
+}
+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;
+    if (provider?.baseUrl !== anthropicOrigin(ctx.baseUrl) || provider?.apiKey !== ctx.apiKey || provider?.api !== 'anthropic-messages') {
+        throw new Error('OpenClaw ScaleMax provider settings are incomplete.');
+    }
+    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` };
 }
 export async function remove(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    return removeManagedConfig(ctx, id, name, file);
+    if (!(await fs.pathExists(file)))
+        return { id, name, changed: false, path: file, message: '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)) {
+        return { id, name, changed: false, path: file, message: 'left unmanaged configuration unchanged' };
+    }
+    delete config.models.providers.scalemax;
+    if (!Object.keys(config.models.providers).length)
+        delete config.models.providers;
+    if (Object.keys(config.models).length === 1 && config.models.mode === 'merge')
+        delete config.models;
+    const defaults = config?.agents?.defaults;
+    if (defaults?.models && typeof defaults.models === 'object') {
+        for (const key of Object.keys(defaults.models))
+            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/'))
+        delete defaults.model;
+    if (defaults?.model?.primary?.startsWith?.('scalemax/')) {
+        delete defaults.model.primary;
+        if (!Object.keys(defaults.model).length)
+            delete defaults.model;
+    }
+    if (defaults && !Object.keys(defaults).length)
+        delete config.agents.defaults;
+    if (config.agents && !Object.keys(config.agents).length)
+        delete config.agents;
+    await backupFile(file, ctx.home);
+    if (Object.keys(config).length)
+        await atomicWrite(file, JSON.stringify(config, null, 2) + '\n', 0o600, ctx.platform);
+    else
+        await fs.remove(file);
+    await removeLegacyArtifact(ctx);
+    return { id, name, changed: true, path: file, message: 'removed only the ScaleMax provider and model entries' };
 }

package/dist/configure/opencode.d.ts

@@ -1,3 +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/opencode.js

@@ -1,33 +1,71 @@
+import fs from 'fs-extra';
+import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
-import { writeManagedConfig, removeManagedConfig } from './common.js';
+import { writeMergedJsonConfig } from './common.js';
+import { modelIds, modelName, openAiBaseUrl, preferredModel } from './models.js';
 const id = 'opencode';
 const name = 'OpenCode';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function providerConfig(ctx) {
+    const models = Object.fromEntries(modelIds(ctx).map(modelId => {
+        const metadata = (ctx.models || []).find(model => model.id === modelId);
+        return [modelId, {
+                name: modelName(ctx, modelId),
+                limit: {
+                    context: metadata?.context_window || (modelId.startsWith('claude-') ? 200000 : 128000),
+                    output: Math.min(metadata?.max_output_tokens || 4096, 4096)
+                }
+            }];
+    }));
+    return {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'ScaleMax',
+        options: { baseURL: openAiBaseUrl(ctx.baseUrl), apiKey: ctx.apiKey },
+        models
+    };
+}
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const content = JSON.stringify({
-        $schema: 'https://opencode.ai/config.json',
-        provider: {
-            scalemax: {
-                npm: '@ai-sdk/openai-compatible',
-                name: 'ScaleMax',
-                options: { baseURL: ctx.baseUrl, apiKey: ctx.apiKey },
-                models: {
-                    'fable-5': { name: 'Fable 5' },
-                    'fable-5-ultra': { name: 'Fable 5 Ultra' },
-                    'gpt-5.6-luna': { name: 'GPT-5.6 Luna' },
-                    'gpt-5.6-terra': { name: 'GPT-5.6 Terra' },
-                    'gpt-5.6-sol': { name: 'GPT-5.6 Sol' },
-                    'gpt-5.4': { name: 'GPT-5.4' },
-                    'gpt-5.4-mini': { name: 'GPT-5.4 Mini' },
-                    'gpt-5.3-codex': { name: 'GPT-5.3 Codex' },
-                    'codex-auto-review': { name: 'Codex Auto Review' }
-                }
-            }
-        }
-    }, null, 2) + '\n';
-    return writeManagedConfig(ctx, id, name, file, content);
+    const selected = `scalemax/${preferredModel(ctx)}`;
+    return writeMergedJsonConfig(ctx, id, name, file, existing => {
+        const providers = asRecord(existing.provider);
+        const currentModel = typeof existing.model === 'string' ? existing.model : undefined;
+        return JSON.stringify({
+            ...existing,
+            $schema: typeof existing.$schema === 'string' ? existing.$schema : 'https://opencode.ai/config.json',
+            provider: { ...providers, scalemax: providerConfig(ctx) },
+            model: !currentModel || currentModel.startsWith('scalemax/') ? selected : currentModel
+        }, null, 2) + '\n';
+    });
+}
+export async function verify(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform);
+    const config = await fs.readJson(file);
+    const provider = config?.provider?.scalemax;
+    if (provider?.npm !== '@ai-sdk/openai-compatible' || provider?.options?.baseURL !== openAiBaseUrl(ctx.baseUrl) || provider?.options?.apiKey !== ctx.apiKey) {
+        throw new Error('OpenCode ScaleMax provider settings are incomplete.');
+    }
+    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).`);
+    return { id, name, changed: false, path: file, message: `verified ${configured.length} ScaleMax models` };
 }
 export async function remove(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    return removeManagedConfig(ctx, id, name, file);
+    if (!(await fs.pathExists(file)))
+        return { id, name, changed: false, path: file, message: 'no ScaleMax configuration found' };
+    const config = await fs.readJson(file).catch(() => undefined);
+    if (!config?.provider?.scalemax || config.provider.scalemax.name !== 'ScaleMax' || config.provider.scalemax.options?.baseURL !== openAiBaseUrl(ctx.baseUrl))
+        return { id, name, changed: false, path: file, message: 'left unmanaged configuration unchanged' };
+    delete config.provider.scalemax;
+    if (!Object.keys(config.provider).length)
+        delete config.provider;
+    if (typeof config.model === 'string' && config.model.startsWith('scalemax/'))
+        delete config.model;
+    await backupFile(file, ctx.home);
+    await atomicWrite(file, JSON.stringify(config, null, 2) + '\n', 0o600, ctx.platform);
+    return { id, name, changed: true, path: file, message: 'removed only the ScaleMax provider' };
 }

package/dist/configure/paths.js

@@ -12,8 +12,8 @@ export function clientConfigPath(id, home, platform, env = process.env) {
         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');
-        case 'openclaw': return path.join(home, '.openclaw', 'config.json');
-        case 'hermes': return path.join(home, '.hermes', 'config', 'scalemax.json');
+        case 'openclaw': return path.join(home, '.openclaw', 'openclaw.json');
+        case 'hermes': return path.join(home, '.hermes', 'config.yaml');
         case 'cherry-studio': return path.join(home, '.scalemax', 'cherry-studio.setup.json');
         case 'api-code': return path.join(home, '.scalemax', 'api-code.examples.json');
     }

package/dist/detect/common.js

@@ -6,6 +6,26 @@ 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': []
 };
 const guiPathDetection = new Set(['trae-solo', 'cherry-studio']);
+function hasNativeScaleMaxConfig(id, text) {
+    if (text.includes(GENERATED_HEADER) || text.includes('"scalemax.managedBy"'))
+        return true;
+    if (!text.includes('api.scalemax.pro'))
+        return false;
+    if (id === 'hermes')
+        return /(?:^|\n)\s*-?\s*name:\s*["']?scalemax["']?\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';
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
 export async function detectClient(ctx, id, name) {
     const config = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
     const cmdHits = [];
@@ -20,7 +40,7 @@ export async function detectClient(ctx, id, name) {
     let configured = false;
     if (await fs.pathExists(config)) {
         const text = await fs.readFile(config, 'utf8').catch(() => '');
-        configured = text.includes(GENERATED_HEADER) || text.includes('"scalemax.managedBy"');
+        configured = hasNativeScaleMaxConfig(id, text);
     }
     const hits = [...cmdHits, ...appHits];
     return { id, name, installed: hits.length > 0, configured, reason: hits.length ? undefined : 'not detected', paths: [...hits, ...(configured ? [config] : [])] };

package/dist/types/client.d.ts

@@ -34,11 +34,15 @@ export interface ConfigureContext extends DetectContext {
     dryRun?: boolean;
     interactive?: boolean;
     allowAppModification?: boolean;
+    providerScope?: ProviderScope;
     models?: Array<{
         id: string;
         object?: string;
         owned_by?: string;
+        provider?: string;
         display_name?: string;
+        context_window?: number | null;
+        max_output_tokens?: number | null;
     }>;
 }
 export interface ConfigureResult {

package/dist/utils/api.d.ts

@@ -3,7 +3,10 @@ export interface ModelInfo {
     id: string;
     object?: string;
     owned_by?: string;
+    provider?: string;
     display_name?: string;
+    context_window?: number | null;
+    max_output_tokens?: number | null;
 }
 export interface KeyMetadata {
     provider_scope: ProviderScope;
@@ -11,6 +14,8 @@ 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<{
     ok: boolean;
     models: ModelInfo[];

package/dist/utils/api.js

@@ -1,5 +1,16 @@
 import { SCALEMAX_BASE_URL } from '../constants.js';
 import { sanitizeApiKey } from './apiKey.js';
+export function isAnthropicModel(model) {
+    const provider = String(model.provider || model.owned_by || '').trim().toLowerCase();
+    if (provider)
+        return provider === 'anthropic' || provider.startsWith('anthropic-');
+    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));
+}
 async function friendlyError(res) {
     let body = '';
     try {
@@ -42,7 +53,8 @@ export async function validateApiKey(apiKey) {
         if (!modelsRes.ok)
             return { ok: false, models: [], key: keyMeta, error: await friendlyError(modelsRes) };
         const data = await modelsRes.json();
-        const models = Array.isArray(data.data) ? data.data : [];
+        const catalog = Array.isArray(data.data) ? data.data : [];
+        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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalemax",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {
@@ -31,7 +31,8 @@
     "chalk": "^5.3.0",
     "execa": "^9.5.1",
     "fs-extra": "^11.2.0",
-    "ora": "^8.1.1"
+    "ora": "^8.1.1",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",