scalemax 0.1.27 → 0.1.28

package/README.md

@@ -125,7 +125,7 @@ Recognized setup, repair, and verification requests execute the CLI's allowliste
 For Claude tool access, run `scalemax claude-tools`, or ask helper-bot to `install GitHub skill tools for Claude Desktop and Claude Code`. Claude Code receives Anthropic's official `example-skills@anthropic-agent-skills` plugin plus public-GitHub read permissions. Claude Desktop/Cowork receives a local MCP server with only three tools: `github_fetch`, `github_tree`, and `github_install_skill`. The MCP server accepts only public GitHub HTTPS hosts, limits downloads, rejects unsafe archive paths and symlinks, refuses to replace an existing skill, and can write only beneath `~/Claude/skills`. It does not expose a general shell, arbitrary URLs, or unrestricted filesystem access. Restart Claude Desktop after installation and use Cowork or Code; a normal Chat tab does not expose local tools.
 Only install skills from repositories you trust: a `SKILL.md` is instruction content that Claude may follow after installation, even though the bridge itself cannot execute arbitrary repository code.
 
-For Roo Code, helper-bot can install VS Code on Windows with the fixed Microsoft winget package, install the official Roo Code extension, write OpenAI and Claude ScaleMax profiles when the key exposes both families, and verify the import handoff. For general troubleshooting that cannot be completed by a fixed client action, helper-bot sends a small `gpt-5.4` request grounded with bundled ScaleMax documentation about stored authentication, credit/token base URLs, provider scope, client setup, and common errors. The language model never generates or executes shell commands; only fixed ScaleMax client detection, installation, configuration, verification, and rollback operations are available to the controller.
+For Roo Code, helper-bot can install VS Code on Windows with the fixed Microsoft winget package, install the official Roo Code extension, write OpenAI and Claude ScaleMax profiles when the key exposes those families, and verify the import handoff. For DeepSeek V4 Flash, helper-bot installs and configures Continue's Chat/Edit integration instead because the Azure deployment has no tool calling. For general troubleshooting that cannot be completed by a fixed client action, helper-bot sends a small `gpt-5.4` request grounded with bundled ScaleMax documentation about stored authentication, credit/token base URLs, provider scope, client setup, and common errors. The language model never generates or executes shell commands; only fixed ScaleMax client detection, installation, configuration, verification, and rollback operations are available to the controller.
 
 The helper refuses unrelated requests and redacts ScaleMax-style secrets from prompts, provider output, errors, and progress notifications. Use `/status` for non-secret connection details, `/help` for commands, and `/quit` to exit.
 
@@ -136,6 +136,7 @@ The helper refuses unrelated requests and redacts ScaleMax-style secrets from pr
 - Codex
 - Cursor
 - Roo Code (VS Code)
+- Continue (VS Code)
 - TRAE SOLO
 - Claude Code
 - OpenCode
@@ -160,7 +161,7 @@ ScaleMax merges a named `scalemax` provider into `~/.config/opencode/opencode.js
 
 ### OpenClaw
 
-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.
+ScaleMax partitions OpenClaw models into native `openai-responses` (`scalemax-codex`, `/v1`), OpenAI-compatible `openai-completions` (`scalemax-deepseek`, `/v1`), and `anthropic-messages` (`scalemax-claude`, origin) providers. `deepseek-v4-flash` is isolated in the Chat Completions provider with tools disabled; it is never advertised through Responses. 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
 
@@ -168,7 +169,11 @@ ScaleMax creates family-specific Hermes providers in `~/.hermes/config.yaml` and
 
 ### 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.
+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. Codex and Claude profiles remain separate. DeepSeek V4 Flash is deliberately not offered in Roo because Roo's task-completion loop requires tool calling and this Azure deployment does not expose it. Reload VS Code once so Roo imports supported profiles into its SecretStorage. CLI verification intentionally reports the handoff as verified, not the extension runtime, until that reload occurs.
+
+### Continue (VS Code)
+
+Continue is the supported VS Code route for `deepseek-v4-flash`. The CLI installs the official `Continue.continue` extension when VS Code is available, merges a Chat/Edit-only OpenAI-compatible model into `~/.continue/config.yaml`, sets `useResponsesApi: false`, and keeps the authenticated ScaleMax key in private `~/.continue/.env` rather than the YAML. Existing Continue models and environment entries are preserved. Reload VS Code, select **ScaleMax DeepSeek V4 Flash**, and use Chat or Edit; Agent mode is unavailable because the deployment does not expose tool calling.
 
 ### Cursor BYOK routing on macOS
 

package/dist/clients.js

@@ -4,6 +4,8 @@ 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 continueDetect from './detect/continue.js';
+import * as continueConfig from './configure/continue.js';
 import * as traeSoloDetect from './detect/trae-solo.js';
 import * as traeSoloConfig from './configure/trae-solo.js';
 import * as claudeDetect from './detect/claude.js';
@@ -22,6 +24,7 @@ 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: 'continue', name: 'Continue (VS Code)', detect: continueDetect.detect, install: continueConfig.install, configure: continueConfig.configure, verify: continueConfig.verify, remove: continueConfig.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

@@ -6,6 +6,7 @@ import { SCALEMAX_BASE_URL } from '../constants.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey, isAnthropicModel } from '../utils/api.js';
 import { homeDir } from '../utils/paths.js';
+import { isDeepSeekChatModelId } from '../configure/models.js';
 export async function detectAll(home = homeDir()) {
     const ctx = { home, platform: process.platform, env: process.env };
     return Promise.all(clients.map(c => c.detect(ctx)));
@@ -44,13 +45,26 @@ export function clientAllowedForModels(clientId, models) {
         return false;
     // These clients use either a native family-specific adapter or the gateway's
     // normalized OpenAI-compatible Chat Completions route, which supports both
-    // authenticated model families. Codex and TRAE remain OpenAI-only.
-    const crossProtocolClients = new Set(['claude', 'cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    // authenticated model families. Codex remains Responses-only; TRAE uses
+    // OpenAI-compatible Chat Completions.
+    const crossProtocolClients = new Set(['cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    if (clientId === 'continue')
+        return models.some(model => isDeepSeekChatModelId(model.id));
+    if (clientId === 'claude')
+        return models.some(isAnthropicModel);
+    if (clientId === 'codex')
+        return models.some(model => !isAnthropicModel(model) && !isDeepSeekChatModelId(model.id));
+    if (clientId === 'hermes' && models.every(model => isDeepSeekChatModelId(model.id)))
+        return false;
+    if (clientId === 'roo-code' && models.every(model => isDeepSeekChatModelId(model.id)))
+        return false;
     if (crossProtocolClients.has(clientId))
         return true;
     return models.some(model => !isAnthropicModel(model));
 }
 function scopeHint(scope) {
+    if (scope === 'deepseek-v4-flash')
+        return 'DeepSeek V4 Flash only';
     return scope === 'both' ? 'OpenAI + Claude' : scope === 'anthropic' ? 'Claude only' : 'OpenAI only';
 }
 export async function configureCommand(opts = {}) {

package/dist/commands/helper-bot.d.ts

@@ -1,7 +1,7 @@
 import { type ChatCompletionOptions, type ChatCompletionResult, type ChatMessage, type ModelInfo } from '../utils/api.js';
 import { loadApiKey } from '../utils/keyStore.js';
 import { validateApiKey } from '../utils/api.js';
-import type { ClientDefinition } from '../types/client.js';
+import type { ClientDefinition, ProviderScope } from '../types/client.js';
 export declare const SCALEMAX_HELPER_REFUSAL: string;
 export declare const SCALEMAX_HELPER_SYSTEM_PROMPT: string;
 export declare const SCALEMAX_HELPER_INVALID_PROVIDER_RESPONSE: string;
@@ -14,7 +14,7 @@ export interface HelperConnection {
     baseUrl: string;
     model: string;
     platform?: NodeJS.Platform;
-    providerScope?: 'openai' | 'anthropic' | 'both';
+    providerScope?: ProviderScope;
     keyMode?: string;
     availableModels?: string[];
     modelCatalog?: ModelInfo[];

package/dist/commands/helper-bot.js

@@ -760,7 +760,8 @@ For automatic configuration, exit with \`/quit\`, run \`scalemax update\`, then
     return reply;
 }
 const HELPER_CLIENT_PATTERNS = [
-    { id: 'roo-code', pattern: /\b(?:roo(?:\s+code)?|roo\s+(?:extension|plugin)|vscode\s+roo|vs\s+code\s+roo|vs\s*code\s+extension|visual\s+studio\s+code\s+extension)\b/i },
+    { id: 'continue', pattern: /\b(?:continue(?:\.dev)?|vscode\s+continue|vs\s+code\s+continue)\b/i },
+    { id: 'roo-code', pattern: /\b(?:roo(?:\s+code)?|roo\s+(?:extension|plugin)|vscode\s+roo|vs\s+code\s+roo)\b/i },
     { id: 'openclaw', pattern: /\bopen\s*claw\b/i },
     { id: 'opencode', pattern: /\bopen\s*code\b/i },
     { id: 'cherry-studio', pattern: /\bcherry\s*studio\b/i },
@@ -799,6 +800,8 @@ function helperActionTarget(question) {
     return undefined;
 }
 function requestedProviderScope(question, target) {
+    if (/\bdeepseek(?:[-\s]+v4[-\s]+flash)?\b/i.test(question))
+        return 'deepseek-v4-flash';
     if (/\b(?:both|openai\s*\+\s*claude|claude\s*\+\s*openai)\b/i.test(question))
         return 'both';
     if (/\b(?:claude|anthropic)\b/i.test(question))
@@ -811,17 +814,32 @@ function actionModels(connection, requestedScope) {
     const catalog = connection.modelCatalog?.length
         ? connection.modelCatalog
         : (connection.availableModels || []).map(id => ({ id }));
-    if (!requestedScope || requestedScope === 'both')
+    if (!requestedScope)
         return catalog;
-    return catalog.filter(model => requestedScope === 'anthropic' ? isAnthropicModel(model) : !isAnthropicModel(model));
+    if (requestedScope === 'deepseek-v4-flash') {
+        return catalog.filter(model => model.id.trim().toLowerCase() === 'deepseek-v4-flash');
+    }
+    if (requestedScope === 'both') {
+        return catalog.filter(model => model.id.trim().toLowerCase() !== 'deepseek-v4-flash');
+    }
+    return catalog.filter(model => requestedScope === 'anthropic'
+        ? isAnthropicModel(model)
+        : !isAnthropicModel(model) && model.id.trim().toLowerCase() !== 'deepseek-v4-flash');
 }
 function helperClientAllowedForModels(clientId, models) {
     if (!models.length)
         return false;
-    const crossProtocolClients = new Set(['claude', 'cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const crossProtocolClients = new Set(['cursor', 'roo-code', 'opencode', 'openclaw', 'hermes', 'cherry-studio', 'api-code']);
+    const onlyDeepSeek = models.every(model => model.id.trim().toLowerCase() === 'deepseek-v4-flash');
+    if (clientId === 'continue')
+        return onlyDeepSeek;
+    if (clientId === 'claude')
+        return models.some(isAnthropicModel);
+    if ((clientId === 'codex' || clientId === 'hermes' || clientId === 'roo-code') && onlyDeepSeek)
+        return false;
     if (crossProtocolClients.has(clientId))
         return true;
-    return models.some(model => !isAnthropicModel(model));
+    return models.some(model => !isAnthropicModel(model) && model.id.trim().toLowerCase() !== 'deepseek-v4-flash');
 }
 function hasRooCodeExtension(paths) {
     return paths.some(candidate => /^rooveterinaryinc\.roo-cline-/i.test(path.basename(candidate)));
@@ -905,9 +923,9 @@ async function installRooCodeExtension(ctx, client, write) {
 async function runOneHelperClientAction(kind, client, connection, home, requestedScope, write) {
     const models = actionModels(connection, requestedScope);
     if (!models.length)
-        throw new Error(`The authenticated key does not expose ${requestedScope === 'anthropic' ? 'Claude' : requestedScope === 'openai' ? 'OpenAI' : 'compatible'} models for ${client.name}. No configuration was changed.`);
-    if (client.id === 'codex' && models.every(isAnthropicModel))
-        throw new Error('Codex requires an OpenAI-compatible model, but this key exposes only Claude models. No configuration was changed.');
+        throw new Error(`The authenticated key does not expose ${requestedScope === 'anthropic' ? 'Claude' : requestedScope === 'openai' ? 'OpenAI' : requestedScope === 'deepseek-v4-flash' ? 'DeepSeek V4 Flash' : 'compatible'} models for ${client.name}. No configuration was changed.`);
+    if (client.id === 'codex' && models.every(model => isAnthropicModel(model) || model.id.trim().toLowerCase() === 'deepseek-v4-flash'))
+        throw new Error('Codex requires a Responses-capable model, but this key exposes only Claude or Chat-Completions-only models. No configuration was changed.');
     if (client.id === 'cursor' && connection.platform !== 'darwin')
         throw new Error(`Automatic Cursor configuration is currently verified on macOS only. ${helperPlatformName(connection.platform)} was not modified.`);
     const ctx = {
@@ -978,7 +996,9 @@ async function runOneHelperClientAction(kind, client, connection, home, requeste
             throw new Error(`${client.name} configuration was written but could not be detected afterward.`);
         write(`✓ ${client.name} configuration detected after write.`);
     }
-    const activation = client.id === 'roo-code' ? ' Reload VS Code once so Roo Code imports the verified ScaleMax profile.' : '';
+    const activation = client.id === 'roo-code'
+        ? ' Reload VS Code once so Roo Code imports the verified ScaleMax profile.'
+        : client.id === 'continue' ? ' Reload VS Code once so Continue loads the verified ScaleMax profile.' : '';
     return `✅ Successfully completed: ${client.name} is configured and locally verified.${activation}`;
 }
 /** Execute only narrowly allowlisted ScaleMax client actions; never model-generated shell commands. */

package/dist/commands/helper-docs.js

@@ -14,14 +14,20 @@ export const HELPER_DOC_SECTIONS = [
     {
         id: 'provider-scope',
         title: 'Provider scope and visible models',
-        keywords: ['provider', 'scope', 'openai', 'claude', 'anthropic', 'both', 'models', 'fable'],
-        content: `A ScaleMax key may be OpenAI only, Claude only, or both. OpenAI-only keys should configure OpenAI-compatible models only. Claude-only keys should configure Claude-compatible models only. Both-scope keys may configure both model families in clients that can switch profiles. Fable 5 is a Claude-family frontend model through ScaleMax and should only appear for Claude-capable or both-scope keys, not OpenAI-only keys.`
+        keywords: ['provider', 'scope', 'openai', 'claude', 'anthropic', 'deepseek', 'both', 'models', 'fable'],
+        content: `A ScaleMax key may be OpenAI only, Claude only, both, or the exact-model DeepSeek V4 Flash entitlement. OpenAI-only keys should configure OpenAI-compatible models only. Claude-only keys should configure Claude-compatible models only. Both-scope keys may configure both model families in clients that can switch profiles. Fable 5 is a Claude-family frontend model through ScaleMax and should only appear for Claude-capable or both-scope keys, not OpenAI-only keys. A DeepSeek V4 Flash key discovers only deepseek-v4-flash; broad OpenAI and both scopes do not inherit that entitlement. The model uses the OpenAI-compatible /v1/chat/completions route with streaming and max_tokens; it must not be placed on a Responses route or advertised as tool-capable.`
     },
     {
         id: 'roo-code',
         title: 'Roo Code setup through VS Code',
-        keywords: ['roo', 'roo code', 'vscode', 'vs code', 'extension', 'visual studio code'],
-        content: `For Roo Code, the ScaleMax CLI writes a private settings import file at ~/.scalemax/roo-code-import.json and sets roo-cline.autoImportSettingsPath in VS Code User settings. Roo imports that profile after VS Code is reloaded. The CLI can install the official Roo Code extension with code --install-extension RooVeterinaryInc.roo-cline when VS Code is detected. On Windows, helper-bot may install VS Code first with winget using the fixed Microsoft.VisualStudioCode package id, then install Roo, write the import handoff, and verify the files.`
+        keywords: ['roo', 'roo code', 'vscode', 'vs code', 'extension', 'visual studio code', 'deepseek'],
+        content: `For Roo Code, the ScaleMax CLI writes a private settings import file at ~/.scalemax/roo-code-import.json and sets roo-cline.autoImportSettingsPath in VS Code User settings. Roo imports that profile after VS Code is reloaded. Roo is not offered for a DeepSeek V4 Flash-only key because Roo's task loop requires tool calling and this Azure deployment does not expose it; use Continue Chat/Edit instead. The CLI can install the official Roo Code extension with code --install-extension RooVeterinaryInc.roo-cline when VS Code is detected. On Windows, helper-bot may install VS Code first with winget using the fixed Microsoft.VisualStudioCode package id, then install Roo, write the import handoff, and verify the files.`
+    },
+    {
+        id: 'continue-deepseek',
+        title: 'Continue setup for DeepSeek V4 Flash',
+        keywords: ['continue', 'continue dev', 'vscode', 'vs code', 'extension', 'deepseek', 'deepseek-v4-flash'],
+        content: `Continue is the supported VS Code integration for DeepSeek V4 Flash. scalemax update installs the official Continue extension when VS Code is available, writes a private ~/.continue/config.yaml Chat/Edit profile, stores the authenticated ScaleMax key in private ~/.continue/.env, and forces useResponsesApi: false. Reload VS Code after setup. Do not use Agent mode and do not request or configure a DeepSeek, Azure, or other upstream credential.`
     },
     {
         id: 'codex-and-clients',

package/dist/configure/codex.js

@@ -5,7 +5,7 @@ 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';
+import { preferredOpenAiResponsesModel } from './models.js';
 const id = 'codex';
 const name = 'Codex';
 const provider = 'scalemax';
@@ -14,7 +14,7 @@ const reasoningEffort = 'medium';
 function selectedModel(ctx) {
     if (!ctx.models)
         return fallbackModel;
-    return preferredOpenAiModel(ctx);
+    return preferredOpenAiResponsesModel(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`;

package/dist/configure/continue.d.ts

@@ -0,0 +1,5 @@
+import { ConfigureContext, ConfigureResult, InstallContext } from '../types/client.js';
+export declare function install(ctx: InstallContext): Promise<ConfigureResult>;
+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/continue.js

@@ -0,0 +1,185 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { parseDocument } from 'yaml';
+import { atomicWrite, backupFile } from '../utils/fs.js';
+import { commandExists } from '../utils/exec.js';
+import { clientConfigPath } from './paths.js';
+import { isDeepSeekChatModelId } from './models.js';
+const id = 'continue';
+const name = 'Continue (VS Code)';
+const modelName = 'ScaleMax DeepSeek V4 Flash';
+const modelId = 'deepseek-v4-flash';
+const envKey = 'SCALEMAX_API_KEY';
+const envMarker = '# ScaleMax managed Continue API key';
+const userAgent = 'ScaleMax-Continue/1.0';
+function envPath(home) { return path.join(home, '.continue', '.env'); }
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function parseYaml(text) {
+    const doc = parseDocument(text || '{}');
+    if (doc.errors.length)
+        throw new Error(`Continue config.yaml is invalid: ${doc.errors[0].message}`);
+    if (!doc.contents)
+        doc.contents = doc.createNode({});
+    const root = doc.toJS();
+    if (!root || typeof root !== 'object' || Array.isArray(root))
+        throw new Error('Continue config.yaml must contain a YAML object.');
+    return doc;
+}
+function isManagedModel(model) {
+    return model?.name === modelName
+        && ['azure', 'openai'].includes(model?.provider)
+        && model?.model === modelId
+        && typeof model?.apiBase === 'string'
+        && /^https:\/\/api\.scalemax\.pro\/(?:token\/)?v1\/?$/i.test(model.apiBase);
+}
+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 requireDeepSeek(ctx) {
+    if (!(ctx.models || []).some(model => isDeepSeekChatModelId(model.id))) {
+        throw new Error('Continue automatic setup for this integration requires a DeepSeek V4 Flash key. No configuration was changed.');
+    }
+}
+export async function install(ctx) {
+    const extensionRoots = [path.join(ctx.home, '.vscode', 'extensions'), path.join(ctx.home, '.vscode-insiders', 'extensions')];
+    for (const root of extensionRoots) {
+        const entries = await fs.readdir(root).catch(() => []);
+        if (entries.some(entry => /^continue\.continue-/i.test(entry)))
+            return { id, name, changed: false, message: 'extension is already installed' };
+    }
+    if (!(await commandExists('code', ctx.env)))
+        throw new Error('VS Code was not detected. Install VS Code, then retry Continue setup.');
+    const result = await execa('code', ['--install-extension', 'Continue.continue', '--force'], { env: ctx.env, reject: false, all: true });
+    if (result.exitCode !== 0)
+        throw new Error(`Continue extension installation failed: ${result.all?.trim() || `code exited with ${result.exitCode}`}`);
+    return { id, name, changed: true, message: 'official Continue extension installed' };
+}
+export async function configure(ctx) {
+    requireDeepSeek(ctx);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const secrets = envPath(ctx.home);
+    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 existingModels = Array.isArray(data.models) ? data.models.filter((model) => !isManagedModel(model)) : [];
+    const model = {
+        name: modelName,
+        provider: 'azure',
+        model: modelId,
+        apiBase: ctx.baseUrl.replace(/\/$/, ''),
+        apiKey: `\${{ secrets.${envKey} }}`,
+        useResponsesApi: false,
+        roles: ['chat', 'edit'],
+        requestOptions: { headers: { 'User-Agent': userAgent } },
+        env: { apiType: 'openai-compatible' },
+        defaultCompletionOptions: { maxTokens: 4096 }
+    };
+    if (!data.name)
+        doc.set('name', 'ScaleMax');
+    if (!data.version)
+        doc.set('version', '1.0.0');
+    if (!data.schema)
+        doc.set('schema', 'v1');
+    doc.set('models', [...existingModels, model]);
+    const nextConfig = String(doc);
+    const nextEnv = managedEnv(originalEnv, ctx.apiKey);
+    if (originalConfig === nextConfig && originalEnv === nextEnv) {
+        await fs.chmod(file, 0o600).catch(() => undefined);
+        await fs.chmod(secrets, 0o600).catch(() => undefined);
+        return { id, name, changed: false, path: file, message: 'DeepSeek V4 Flash Chat/Edit profile is already current' };
+    }
+    const backups = [await backupFile(file, ctx.home), await backupFile(secrets, ctx.home)].filter(Boolean);
+    try {
+        await atomicWrite(file, nextConfig, 0o600, ctx.platform);
+        await atomicWrite(secrets, nextEnv, 0o600, ctx.platform);
+    }
+    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 a text-only DeepSeek V4 Flash Chat/Edit profile with a private credential${backups.length ? ' (backups created)' : ''}` };
+}
+export async function verify(ctx) {
+    requireDeepSeek(ctx);
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const secrets = envPath(ctx.home);
+    const doc = parseYaml(await fs.readFile(file, 'utf8'));
+    const data = asRecord(doc.toJS());
+    const model = Array.isArray(data.models)
+        ? data.models.find((candidate) => isManagedModel(candidate) && candidate.provider === 'azure')
+        : undefined;
+    if (!model
+        || model.apiBase !== ctx.baseUrl.replace(/\/$/, '')
+        || model.apiKey !== `\${{ secrets.${envKey} }}`
+        || model.useResponsesApi !== false
+        || JSON.stringify(model.roles) !== JSON.stringify(['chat', 'edit'])
+        || model.requestOptions?.headers?.['User-Agent'] !== userAgent
+        || model.env?.apiType !== 'openai-compatible'
+        || model.defaultCompletionOptions?.maxTokens !== 4096) {
+        throw new Error('Continue DeepSeek V4 Flash Chat/Edit configuration is incomplete.');
+    }
+    const env = await fs.readFile(secrets, 'utf8').catch(() => '');
+    if (!env.includes(envMarker) || !env.includes(`${envKey}=${ctx.apiKey}`))
+        throw new Error('Continue is missing its authenticated ScaleMax credential.');
+    if (ctx.platform !== 'win32') {
+        for (const candidate of [file, secrets])
+            if (((await fs.stat(candidate)).mode & 0o077) !== 0)
+                throw new Error(`Continue file permissions are too broad: ${candidate}`);
+    }
+    return { id, name, changed: false, path: file, message: 'verified DeepSeek V4 Flash Chat/Edit configuration; reload VS Code to activate it' };
+}
+export async function remove(ctx) {
+    const file = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const secrets = envPath(ctx.home);
+    if (!(await fs.pathExists(file)))
+        return { id, name, changed: false, path: file, message: 'no ScaleMax Continue configuration found' };
+    const original = await fs.readFile(file, 'utf8');
+    const doc = parseYaml(original);
+    const data = asRecord(doc.toJS());
+    const models = Array.isArray(data.models) ? data.models : [];
+    const remaining = models.filter((model) => !isManagedModel(model));
+    if (remaining.length === models.length)
+        return { id, name, changed: false, path: file, message: 'left unmanaged Continue configuration unchanged' };
+    await backupFile(file, ctx.home);
+    const currentEnv = await fs.readFile(secrets, 'utf8').catch(() => '');
+    if (currentEnv)
+        await backupFile(secrets, ctx.home);
+    if (remaining.length)
+        doc.set('models', remaining);
+    else
+        doc.delete('models');
+    const nextData = asRecord(doc.toJS());
+    const generatedOnly = !remaining.length
+        && Object.keys(nextData).every(key => ['name', 'version', 'schema'].includes(key))
+        && data.name === 'ScaleMax';
+    if (generatedOnly)
+        await fs.remove(file);
+    else
+        await atomicWrite(file, String(doc), 0o600, ctx.platform);
+    const nextEnv = withoutManagedEnv(currentEnv);
+    if (nextEnv)
+        await atomicWrite(secrets, nextEnv, 0o600, ctx.platform);
+    else
+        await fs.remove(secrets).catch(() => undefined);
+    return { id, name, changed: true, path: file, message: 'removed only the ScaleMax DeepSeek model and managed credential' };
+}

package/dist/configure/hermes.js

@@ -4,7 +4,7 @@ import { parseDocument } from 'yaml';
 import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
 import { isScaleMaxManagedText } from './common.js';
-import { anthropicModelIds, anthropicOrigin, openAiBaseUrl, openAiModelIds, preferredAnthropicModel, preferredOpenAiModel } from './models.js';
+import { anthropicModelIds, anthropicOrigin, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredOpenAiResponsesModel } from './models.js';
 const id = 'hermes';
 const name = 'Hermes';
 const envKey = 'SCALEMAX_HERMES_API_KEY';
@@ -64,7 +64,7 @@ export async function configure(ctx) {
     const originalEnv = await fs.readFile(secrets, 'utf8').catch(() => '');
     const doc = parseYaml(originalConfig);
     const data = asRecord(doc.toJS());
-    const codexIds = openAiModelIds(ctx);
+    const codexIds = openAiResponsesModelIds(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)) : [];
@@ -95,7 +95,7 @@ export async function configure(ctx) {
     if (activatesScaleMax) {
         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);
+        const activeModel = activeName === codexProviderName ? preferredOpenAiResponsesModel(ctx) : preferredAnthropicModel(ctx);
         doc.set('model', { ...currentModel, provider: `custom:${activeName}`, default: activeModel, max_tokens: 4096 });
     }
     const nextConfig = String(doc);
@@ -131,7 +131,7 @@ export async function verify(ctx) {
     const doc = parseYaml(await fs.readFile(file, 'utf8'));
     const data = asRecord(doc.toJS());
     const providers = Array.isArray(data.custom_providers) ? data.custom_providers : [];
-    const codexIds = openAiModelIds(ctx);
+    const codexIds = openAiResponsesModelIds(ctx);
     const claudeIds = anthropicModelIds(ctx);
     const codex = providers.find((candidate) => candidate?.name === codexProviderName);
     const claude = providers.find((candidate) => candidate?.name === claudeProviderName);

package/dist/configure/models.d.ts

@@ -1,9 +1,16 @@
 import { ConfigureContext } from '../types/client.js';
+export declare const DEEPSEEK_V4_FLASH_MODEL_ID = "deepseek-v4-flash";
+export declare function isDeepSeekChatModelId(id: string): boolean;
 export declare function modelIds(ctx: ConfigureContext): string[];
 export declare function anthropicModelIds(ctx: ConfigureContext): string[];
 export declare function openAiModelIds(ctx: ConfigureContext): string[];
+/** Models that must stay on the OpenAI-compatible Chat Completions route. */
+export declare function deepSeekChatModelIds(ctx: ConfigureContext): string[];
+/** Non-Anthropic models that may remain on existing Responses-based clients. */
+export declare function openAiResponsesModelIds(ctx: ConfigureContext): string[];
 export declare function preferredAnthropicModel(ctx: ConfigureContext): string;
 export declare function preferredOpenAiModel(ctx: ConfigureContext): string;
+export declare function preferredOpenAiResponsesModel(ctx: ConfigureContext): string;
 /**
  * OpenAI-compatible chat clients can use the gateway's normalized chat route
  * for either family. Keep an OpenAI model as the default when one is present

package/dist/configure/models.js

@@ -14,8 +14,13 @@ const preferredOpenAi = [
     'gpt-5.4',
     'gpt-5.4-mini',
     'gpt-5.3-codex',
-    'codex-auto-review'
+    'codex-auto-review',
+    'deepseek-v4-flash'
 ];
+export const DEEPSEEK_V4_FLASH_MODEL_ID = 'deepseek-v4-flash';
+export function isDeepSeekChatModelId(id) {
+    return id.trim().toLowerCase() === DEEPSEEK_V4_FLASH_MODEL_ID;
+}
 export function modelIds(ctx) {
     return [...new Set((ctx.models || []).map(model => model.id.trim()).filter(id => id && !isRetiredModelId(id)))];
 }
@@ -25,6 +30,14 @@ export function anthropicModelIds(ctx) {
 export function openAiModelIds(ctx) {
     return [...new Set((ctx.models || []).filter(model => !isAnthropicModel(model)).map(model => model.id.trim()).filter(id => id && !isRetiredModelId(id)))];
 }
+/** Models that must stay on the OpenAI-compatible Chat Completions route. */
+export function deepSeekChatModelIds(ctx) {
+    return openAiModelIds(ctx).filter(isDeepSeekChatModelId);
+}
+/** Non-Anthropic models that may remain on existing Responses-based clients. */
+export function openAiResponsesModelIds(ctx) {
+    return openAiModelIds(ctx).filter(id => !isDeepSeekChatModelId(id));
+}
 function preferredFrom(ids, candidates, family) {
     for (const candidate of candidates)
         if (ids.includes(candidate))
@@ -39,6 +52,9 @@ export function preferredAnthropicModel(ctx) {
 export function preferredOpenAiModel(ctx) {
     return preferredFrom(openAiModelIds(ctx), preferredOpenAi, 'Codex/OpenAI');
 }
+export function preferredOpenAiResponsesModel(ctx) {
+    return preferredFrom(openAiResponsesModelIds(ctx), preferredOpenAi, 'Codex/OpenAI');
+}
 /**
  * OpenAI-compatible chat clients can use the gateway's normalized chat route
  * for either family. Keep an OpenAI model as the default when one is present
@@ -75,6 +91,8 @@ export function modelName(ctx, id) {
     const model = (ctx.models || []).find(candidate => candidate.id === id);
     if (model?.display_name)
         return model.display_name;
+    if (isDeepSeekChatModelId(id))
+        return 'DeepSeek V4 Flash';
     return id.split('-').map(part => part ? part[0].toUpperCase() + part.slice(1) : part).join(' ');
 }
 export function anthropicOrigin(baseUrl) {

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 { anthropicModelIds, anthropicOrigin, fastModel, fastOpenAiModel, modelName, openAiBaseUrl, openAiModelIds, preferredAnthropicModel, preferredOpenAiModel } from './models.js';
+import { anthropicModelIds, anthropicOrigin, deepSeekChatModelIds, fastModel, fastOpenAiModel, modelName, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredOpenAiResponsesModel } from './models.js';
 import { removeClientSecret, rollbackClientSecret, verifyClientSecret, writeClientSecret } from './client-secret.js';
 const id = 'openclaw';
 const name = 'OpenClaw';
@@ -16,6 +16,7 @@ const userAgentValue = 'ScaleMax-OpenClaw/1.0';
 const userAgentReference = { source: 'file', provider: userAgentProviderId, id: 'value' };
 const legacyProviderName = 'scalemax';
 const codexProviderName = 'scalemax-codex';
+const deepSeekProviderName = 'scalemax-deepseek';
 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'); }
@@ -40,6 +41,10 @@ function entries(ctx, ids, family) {
             input: family === 'anthropic' ? ['text', 'image'] : ['text'],
             maxTokens: Math.min(metadata?.max_output_tokens || 4096, 4096)
         };
+        if (family === 'deepseek') {
+            result.reasoning = false;
+            result.compat = { supportsTools: false };
+        }
         if (metadata?.context_window || family === 'anthropic')
             result.contextWindow = metadata?.context_window || 200000;
         return result;
@@ -78,7 +83,7 @@ async function scrubGeneratedPlaintextCredentials(ctx) {
         for (const providers of roots) {
             for (const [providerName, rawProvider] of Object.entries(providers)) {
                 const provider = asRecord(rawProvider);
-                const isScaleMax = [legacyProviderName, codexProviderName, claudeProviderName].includes(providerName)
+                const isScaleMax = [legacyProviderName, codexProviderName, deepSeekProviderName, claudeProviderName].includes(providerName)
                     && isScaleMaxBaseUrl(provider.baseUrl);
                 if (isScaleMax && typeof provider.apiKey === 'string') {
                     delete provider.apiKey;
@@ -96,11 +101,14 @@ async function scrubGeneratedPlaintextCredentials(ctx) {
 }
 export async function configure(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
-    const codexIds = openAiModelIds(ctx);
+    const codexIds = openAiResponsesModelIds(ctx);
+    const deepSeekIds = deepSeekChatModelIds(ctx);
     const claudeIds = anthropicModelIds(ctx);
-    const codexPrimary = codexIds.length ? `${codexProviderName}/${preferredOpenAiModel(ctx)}` : undefined;
+    const codexPrimary = codexIds.length ? `${codexProviderName}/${preferredOpenAiResponsesModel(ctx)}` : undefined;
+    const deepSeekPrimary = deepSeekIds.length ? `${deepSeekProviderName}/${deepSeekIds[0]}` : undefined;
     const claudePrimary = claudeIds.length ? `${claudeProviderName}/${preferredAnthropicModel(ctx)}` : undefined;
     const codexQuick = fastOpenAiModel(ctx);
+    const deepSeekQuick = deepSeekIds[0];
     const claudeQuick = fastModel(ctx);
     let secret = { changed: false };
     let userAgentSecret = { changed: false };
@@ -117,26 +125,34 @@ export async function configure(ctx) {
             const defaults = asRecord(agents.defaults);
             const allowlist = asRecord(defaults.models);
             for (const key of Object.keys(allowlist)) {
-                if (key.startsWith(`${legacyProviderName}/`) || key.startsWith(`${codexProviderName}/`) || key.startsWith(`${claudeProviderName}/`))
+                if (key.startsWith(`${legacyProviderName}/`) || key.startsWith(`${codexProviderName}/`) || key.startsWith(`${deepSeekProviderName}/`) || key.startsWith(`${claudeProviderName}/`))
                     delete allowlist[key];
             }
             for (const modelId of codexIds)
                 allowlist[`${codexProviderName}/${modelId}`] = {};
+            for (const modelId of deepSeekIds)
+                allowlist[`${deepSeekProviderName}/${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 currentId = String(currentPrimary || '').split('/').slice(1).join('/');
+            const keepDeepSeek = String(currentPrimary || '').startsWith(`${deepSeekProviderName}/`) || deepSeekIds.includes(currentId);
             const keepClaude = String(currentPrimary || '').startsWith(`${claudeProviderName}/`) || claudeIds.includes(currentId);
-            const primary = keepClaude ? claudePrimary || codexPrimary : codexPrimary || claudePrimary;
+            const primary = keepDeepSeek
+                ? deepSeekPrimary || codexPrimary || claudePrimary
+                : keepClaude
+                    ? claudePrimary || codexPrimary || deepSeekPrimary
+                    : codexPrimary || deepSeekPrimary || claudePrimary;
             const usesClaude = Boolean(primary?.startsWith(`${claudeProviderName}/`));
+            const usesDeepSeek = Boolean(primary?.startsWith(`${deepSeekProviderName}/`));
             const nextModel = activatesScaleMax
                 ? { ...asRecord(currentModel), ...(primary ? { primary } : {}) }
                 : currentModel;
             const currentUtility = typeof defaults.utilityModel === 'string' ? defaults.utilityModel : undefined;
-            const quick = usesClaude ? claudeQuick : codexQuick;
-            const utilityProvider = usesClaude ? claudeProviderName : codexProviderName;
+            const quick = usesClaude ? claudeQuick : usesDeepSeek ? deepSeekQuick : codexQuick;
+            const utilityProvider = usesClaude ? claudeProviderName : usesDeepSeek ? deepSeekProviderName : codexProviderName;
             const utilityModel = quick && (activatesScaleMax || currentUtility?.startsWith('scalemax')) ? `${utilityProvider}/${quick}` : currentUtility;
             const nextProviders = { ...providers };
             delete nextProviders[legacyProviderName];
@@ -151,6 +167,17 @@ export async function configure(ctx) {
                 };
             else
                 delete nextProviders[codexProviderName];
+            if (deepSeekIds.length)
+                nextProviders[deepSeekProviderName] = {
+                    baseUrl: openAiBaseUrl(ctx.baseUrl),
+                    apiKey: secretReference,
+                    api: 'openai-completions',
+                    maxTokens: 4096,
+                    request: { headers: { 'User-Agent': userAgentReference }, allowPrivateNetwork: false },
+                    models: entries(ctx, deepSeekIds, 'deepseek')
+                };
+            else
+                delete nextProviders[deepSeekProviderName];
             if (claudeIds.length)
                 nextProviders[claudeProviderName] = {
                     baseUrl: anthropicOrigin(ctx.baseUrl),
@@ -191,16 +218,18 @@ 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 Responses (${codexIds.length}) and Anthropic Messages (${claudeIds.length}) providers with file-backed SecretRefs${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}), OpenAI Chat Completions (${deepSeekIds.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 codex = config?.models?.providers?.[codexProviderName];
+    const deepSeek = config?.models?.providers?.[deepSeekProviderName];
     const claude = config?.models?.providers?.[claudeProviderName];
     const secretProvider = config?.secrets?.providers?.[secretProviderId];
     const userAgentProvider = config?.secrets?.providers?.[userAgentProviderId];
-    const codexIds = openAiModelIds(ctx);
+    const codexIds = openAiResponsesModelIds(ctx);
+    const deepSeekIds = deepSeekChatModelIds(ctx);
     const claudeIds = anthropicModelIds(ctx);
     const valid = (provider, baseUrl, api, ids) => {
         const userAgent = provider?.request?.headers?.['User-Agent'];
@@ -211,7 +240,11 @@ export async function verify(ctx) {
             && userAgent?.source === userAgentReference.source && userAgent?.provider === userAgentReference.provider
             && userAgent?.id === userAgentReference.id && configured.size === ids.length && ids.every(model => configured.has(model));
     };
+    const deepSeekModels = Array.isArray(deepSeek?.models) ? deepSeek.models : [];
+    const deepSeekValid = valid(deepSeek, openAiBaseUrl(ctx.baseUrl), 'openai-completions', deepSeekIds)
+        && deepSeekModels.every((model) => model?.compat?.supportsTools === false);
     if ((codexIds.length ? !valid(codex, openAiBaseUrl(ctx.baseUrl), 'openai-responses', codexIds) : Boolean(codex))
+        || (deepSeekIds.length ? !deepSeekValid : Boolean(deepSeek))
         || (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') {
@@ -221,7 +254,7 @@ export async function verify(ctx) {
     await verifyClientSecret(userAgentPath(ctx.home), userAgentContext(ctx));
     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` };
+    return { id, name, changed: false, path: file, message: `verified ${codexIds.length} Responses, ${deepSeekIds.length} DeepSeek Chat Completions, and ${claudeIds.length} Claude models` };
 }
 export async function remove(ctx) {
     const file = clientConfigPath(id, ctx.home, ctx.platform);
@@ -232,7 +265,7 @@ export async function remove(ctx) {
     }
     const config = await fs.readJson(file).catch(() => undefined);
     const providerRoot = asRecord(config?.models?.providers);
-    const managedNames = [legacyProviderName, codexProviderName, claudeProviderName].filter(providerName => {
+    const managedNames = [legacyProviderName, codexProviderName, deepSeekProviderName, claudeProviderName].filter(providerName => {
         const provider = asRecord(providerRoot[providerName]);
         return [anthropicOrigin(ctx.baseUrl), openAiBaseUrl(ctx.baseUrl)].includes(String(provider.baseUrl || ''));
     });

package/dist/configure/paths.js

@@ -10,6 +10,7 @@ export function clientConfigPath(id, home, platform, env = process.env) {
         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 'continue': return path.join(home, '.continue', 'config.yaml');
         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');
@@ -26,6 +27,7 @@ export function installHints(id, home, platform, env = process.env) {
         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 'continue': 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.js

@@ -3,7 +3,7 @@ import fs from 'fs-extra';
 import JSON5 from 'json5';
 import { atomicWrite, backupFile } from '../utils/fs.js';
 import { clientConfigPath } from './paths.js';
-import { anthropicModelIds, openAiBaseUrl, openAiModelIds, preferredAnthropicModel, preferredChatCompletionsModel, preferredOpenAiModel } from './models.js';
+import { anthropicModelIds, isDeepSeekChatModelId, openAiBaseUrl, openAiResponsesModelIds, preferredAnthropicModel, preferredChatCompletionsModel, preferredOpenAiResponsesModel } from './models.js';
 import { isAnthropicModel } from '../utils/api.js';
 const id = 'roo-code';
 const name = 'Roo Code (VS Code)';
@@ -11,12 +11,16 @@ const importSetting = 'roo-cline.autoImportSettingsPath';
 const importSettingValue = '~/.scalemax/roo-code-import.json';
 const codexProfileName = 'ScaleMax Codex';
 const claudeProfileName = 'ScaleMax Claude';
+const deepSeekProfileName = 'ScaleMax DeepSeek';
 const codexProfileId = 'scalemax-codex';
 const claudeProfileId = 'scalemax-claude';
+const deepSeekProfileId = 'scalemax-deepseek';
 function importPath(home) { return path.join(home, '.scalemax', 'roo-code-import.json'); }
 function fallbackProfileFor(ctx) {
     const model = preferredChatCompletionsModel(ctx);
     const metadata = (ctx.models || []).find(candidate => candidate.id === model) || { id: model };
+    if (isDeepSeekChatModelId(model))
+        throw new Error('Roo Code requires task-completion tool calling, which DeepSeek V4 Flash does not expose. Use Continue Chat/Edit in VS Code instead. No configuration was changed.');
     return isAnthropicModel(metadata)
         ? { name: claudeProfileName, id: claudeProfileId, model }
         : { name: codexProfileName, id: codexProfileId, model };
@@ -24,8 +28,9 @@ function fallbackProfileFor(ctx) {
 function profilesFor(ctx) {
     const scope = ctx.providerScope || 'both';
     const profiles = [];
-    if (scope !== 'anthropic' && openAiModelIds(ctx).length) {
-        profiles.push({ name: codexProfileName, id: codexProfileId, model: preferredOpenAiModel(ctx) });
+    const codexIds = openAiResponsesModelIds(ctx);
+    if (scope !== 'anthropic' && codexIds.length) {
+        profiles.push({ name: codexProfileName, id: codexProfileId, model: preferredOpenAiResponsesModel(ctx) });
     }
     if (scope !== 'openai' && anthropicModelIds(ctx).length) {
         profiles.push({ name: claudeProfileName, id: claudeProfileId, model: preferredAnthropicModel(ctx) });
@@ -144,7 +149,8 @@ export async function remove(ctx) {
         const configs = profile?.providerProfiles?.apiConfigs;
         const managed = [
             configs?.[codexProfileName]?.id === codexProfileId,
-            configs?.[claudeProfileName]?.id === claudeProfileId
+            configs?.[claudeProfileName]?.id === claudeProfileId,
+            configs?.[deepSeekProfileName]?.id === deepSeekProfileId
         ].some(Boolean);
         if (managed) {
             await backupFile(profileFile, ctx.home);

package/dist/configure/templates.js

@@ -11,14 +11,15 @@ export function jsonConfig(client, apiKey, baseUrl, extra = {}) {
     }, null, 2) + '\n';
 }
 export function continueConfig(apiKey, baseUrl) {
-    const models = ['gpt-5.6-sol', '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'];
+    const models = ['gpt-5.6-sol', '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', 'deepseek-v4-flash'];
     return JSON.stringify({
         models: models.map(model => ({
-            title: `ScaleMax ${model}`,
+            title: model === 'deepseek-v4-flash' ? 'ScaleMax DeepSeek V4 Flash' : `ScaleMax ${model}`,
             provider: 'openai',
             model,
             apiBase: baseUrl,
-            apiKey
+            apiKey,
+            ...(model === 'deepseek-v4-flash' ? { useResponsesApi: false } : {})
         })),
         tabAutocompleteModel: { title: 'ScaleMax gpt-5.4-mini', provider: 'openai', model: 'gpt-5.4-mini', apiBase: baseUrl, apiKey },
         contextProviders: [{ name: 'code' }, { name: 'docs' }, { name: 'diff' }, { name: 'terminal' }]

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'], 'roo-code': ['code'], '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'], continue: ['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) {

package/dist/detect/continue.d.ts

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

package/dist/detect/continue.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { commandExists } from '../utils/exec.js';
+import { clientConfigPath } from '../configure/paths.js';
+const id = 'continue';
+const name = 'Continue (VS Code)';
+const extensionPattern = /^continue\.continue-/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 config = clientConfigPath(id, ctx.home, ctx.platform, ctx.env);
+    const envFile = path.join(ctx.home, '.continue', '.env');
+    const configText = await fs.readFile(config, 'utf8').catch(() => '');
+    const envText = await fs.readFile(envFile, 'utf8').catch(() => '');
+    const configured = configText.includes('ScaleMax DeepSeek V4 Flash')
+        && configText.includes('deepseek-v4-flash')
+        && configText.includes('api.scalemax.pro')
+        && /^SCALEMAX_API_KEY=/m.test(envText);
+    if (configured)
+        paths.push(config, envFile);
+    const installed = paths.some(entry => extensionPattern.test(path.basename(entry)));
+    return {
+        id,
+        name,
+        installed,
+        configured,
+        executable,
+        installable: executable,
+        reason: installed ? undefined : executable ? 'Continue extension was not detected' : 'VS Code and Continue were not detected',
+        paths
+    };
+}

package/dist/types/client.d.ts

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

package/dist/utils/api.d.ts

@@ -1,4 +1,5 @@
-export type ProviderScope = 'openai' | 'anthropic' | 'both';
+export declare const DEEPSEEK_V4_FLASH_SCOPE: "deepseek-v4-flash";
+export type ProviderScope = 'openai' | 'anthropic' | 'both' | typeof DEEPSEEK_V4_FLASH_SCOPE;
 export interface ModelInfo {
     id: string;
     object?: string;

package/dist/utils/api.js

@@ -1,5 +1,6 @@
 import { SCALEMAX_BASE_URL, SCALEMAX_TOKEN_BASE_URL } from '../constants.js';
 import { redactApiKey, sanitizeApiKey } from './apiKey.js';
+export const DEEPSEEK_V4_FLASH_SCOPE = 'deepseek-v4-flash';
 // Keep only aliases that are no longer offered. Direct GPT-5.6 Sol is an
 // active Codex model and must remain available to all generated clients.
 export const RETIRED_MODEL_IDS = new Set(['fable-5-ultra']);
@@ -13,8 +14,27 @@ export function isAnthropicModel(model) {
     return model.id.startsWith('claude-') && !model.id.startsWith('claude-fable-');
 }
 export function filterModelsForScope(models, scope) {
-    return models.filter(model => !isRetiredModelId(model.id)
-        && (scope === 'both' || (scope === 'anthropic' ? isAnthropicModel(model) : !isAnthropicModel(model))));
+    return models.filter(model => {
+        if (isRetiredModelId(model.id))
+            return false;
+        const isDeepSeekV4Flash = model.id.trim().toLowerCase() === DEEPSEEK_V4_FLASH_SCOPE;
+        // This scope is an exact-model entitlement, not an OpenAI-compatible
+        // provider family. Mirror the gateway's fail-closed authorization so an
+        // unexpectedly broad catalog can never widen a customer's key locally.
+        if (isDeepSeekV4Flash)
+            return scope === DEEPSEEK_V4_FLASH_SCOPE;
+        if (scope === DEEPSEEK_V4_FLASH_SCOPE)
+            return false;
+        return scope === 'both' || (scope === 'anthropic' ? isAnthropicModel(model) : !isAnthropicModel(model));
+    });
+}
+function providerScope(value) {
+    return value === 'openai'
+        || value === 'anthropic'
+        || value === 'both'
+        || value === DEEPSEEK_V4_FLASH_SCOPE
+        ? value
+        : null;
 }
 async function friendlyError(res) {
     let body = '';
@@ -112,7 +132,11 @@ async function validateOnSurface(apiKey, baseUrl) {
         if (!authCheck.ok)
             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 };
+        const rawScope = usage?.key?.provider_scope ?? 'both';
+        const parsedScope = providerScope(rawScope);
+        if (!parsedScope)
+            return { ok: false, models: [], error: 'ScaleMax returned an unsupported API-key model scope.' };
+        const keyMeta = { provider_scope: parsedScope, mode: usage?.key?.mode, prefix: usage?.key?.prefix, label: usage?.key?.label };
         if (!modelsRes.ok)
             return { ok: false, models: [], key: keyMeta, error: redactApiKey(await friendlyError(modelsRes), apiKey) };
         const data = await modelsRes.json();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalemax",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "Universal ScaleMax installer for AI coding clients",
   "type": "module",
   "bin": {
@@ -53,6 +53,7 @@
     "installer",
     "codex",
     "cursor",
+    "continue",
     "trae-solo",
     "claude-code",
     "opencode",