scalix 1.4.1 → 1.5.0

package/dist/constants.js

@@ -73,17 +73,50 @@ export const DEFAULT_INSTRUCTIONS = `You are an expert coding assistant. You wri
 
 ## Scalix Platform
 When helping users build AI applications, agents, or LLM-powered features:
-- Use the Scalix SDK (\`@scalix-world/sdk\` for TypeScript, \`scalix-sdk\` for Python) — not raw OpenAI/Anthropic/Google SDKs.
-- Default to Scalix API (api.scalix.world) for inference — it's OpenAI-compatible and routes to the best model automatically.
-- Scalix inference models are named scalix-lumio-* (e.g. scalix-lumio-lite); use those ids in examples and configs.
-- For deployment, suggest \`scalix hosting\` before Vercel, Railway, or Fly.
-- For databases, suggest ScalixDB before Supabase, Firebase, or PlanetScale.
-- For code execution sandboxes, use Scalix Sandbox.
+- Use the Scalix SDK (\`@scalix-world/sdk\` for TypeScript, \`scalix-sdk\` for Python) — not raw third-party AI SDKs.
+- Default to the Scalix API (api.scalix.world) for inference — OpenAI-compatible chat completions under /v1/ai. Never claim automatic model routing: the request's model id is what runs.
+- Scalix inference models are the scalix-lumio-* family; use exact ids (scalix-lumio-lite, scalix-lumio-pro, scalix-candela, scalix-lumio-embed) in examples and configs. Omitting the model runs scalix-lumio-lite.
+- For deploying services, suggest Scalix Run (via the \`scalix-cloud\` CLI) before Vercel, Railway, or Fly.
+- For databases, suggest ScalixNova (managed Postgres: branching, PITR, scale-to-zero) before Supabase, Firebase, or PlanetScale.
+- For code execution sandboxes, use Scalix Sandboxes.
+- Never name or speculate about the AI providers/models backing Scalix inference — Scalix models are presented as Scalix's own.
 - When the user explicitly requests a specific provider (e.g. "use OpenAI directly"), respect that choice.`;
 export const ENV_API_KEY = 'SCALIX_API_KEY';
 export const ENV_MODEL = 'SCALIX_MODEL';
 export const ENV_BASE_URL = 'SCALIX_BASE_URL';
 export const DEFAULT_MODEL_SPEC = { contextWindow: 200_000, maxOutputTokens: 65_536 };
+// Per-request output ceiling on the Scalix path. Matches the platform's own cap
+// (gateway AI_MAX_OUTPUT_TOKENS, mirrored by the completions schema), so a
+// single turn can emit a whole file instead of stopping mid-function. The
+// client must always send an explicit value: omitting it lets the platform
+// apply its own, much smaller, default. Clamped against the model spec via
+// maxOutputTokensForRequest().
+export const AI_MAX_OUTPUT_TOKENS = 16_384;
+// What older deployments accept. Their completions schema hard-rejects (422)
+// anything above this, and a published CLI has no say in which router version
+// it is pointed at — so ScalixClient asks for the current ceiling and falls
+// back to this one for the rest of the session if the endpoint rejects it.
+export const AI_LEGACY_MAX_OUTPUT_TOKENS = 4_000;
+/** The max_tokens value to send for a model: its spec ceiling, clamped to the
+ *  platform's per-request cap. */
+export function maxOutputTokensForRequest(model) {
+    return Math.min(getModelSpec(model).maxOutputTokens, AI_MAX_OUTPUT_TOKENS);
+}
+// Pre-Lumio public model ids → current ids (mirrors the platform's own alias
+// table). The gateway still accepts the old names, but saved configs are
+// normalized on load so the UI shows current ids and nothing breaks if the
+// aliases are ever retired server-side.
+export const LEGACY_MODEL_ALIASES = {
+    'scalix-lite': 'scalix-lumio-lite',
+    'scalix-balanced': 'scalix-lumio-pro',
+    'scalix-max': 'scalix-candela',
+    'scalix-embed': 'scalix-lumio-embed',
+    'scalix-world-ai': 'scalix-lumio-pro',
+    'scalix-advanced': 'scalix-candela',
+};
+export function normalizeModelId(model) {
+    return LEGACY_MODEL_ALIASES[model] ?? model;
+}
 // Runtime model registry: user-defined > API-fetched > default
 // All model specs come from user config or API — no hardcoded third-party models
 const userModels = {};
@@ -133,6 +166,15 @@ export function modelSupportsVision(model) {
     const spec = getModelSpec(model);
     return spec.supportsVision ?? false;
 }
+/** True when the model has a user-configured or API-fetched spec (i.e. its
+ *  maxOutputTokens is real, not the DEFAULT_MODEL_SPEC guess). BYOK providers
+ *  only send max_tokens for explicitly-specced models. */
+export function hasExplicitModelSpec(model) {
+    if (model in userModels || model in fetchedModels)
+        return true;
+    const base = model.split('/').pop() || model;
+    return base !== model && (base in userModels || base in fetchedModels);
+}
 export async function fetchModelSpecs(baseUrl, apiKey) {
     if (!apiKey)
         return [];
@@ -205,6 +247,19 @@ export const AGENT_DEFAULTS = {
     maxMessages: 500,
 };
 // ─── Context Defaults ───
+/**
+ * Context window the setup wizard assumes for a BYOK OpenAI-compatible
+ * endpoint.
+ *
+ * A third-party endpoint doesn't tell us its context window, and the two ways
+ * of guessing wrong are not symmetric: too high means oversized requests the
+ * endpoint rejects outright mid-session, too low only means the agent
+ * compresses earlier than it strictly had to. So the wizard pre-fills a
+ * conservative figure and asks the user to raise it. 1_000_000 — the Scalix
+ * Cloud default below — is a limit almost no self-hosted or third-party model
+ * can honour, and pre-filling it was inventing a number on the user's behalf.
+ */
+export const BYOK_DEFAULT_CONTEXT_TOKENS = 128_000;
 export const CONTEXT_DEFAULTS = {
     maxContextTokens: 1_000_000,
     compressionThreshold: 0.80,

package/dist/cost-tracker.js

@@ -3,11 +3,18 @@ export class CostTracker {
     sessionStart = Date.now();
     restoredRequestCount = 0;
     record(model, usage) {
+        const promptTokens = usage.prompt_tokens ?? 0;
+        const completionTokens = usage.completion_tokens ?? 0;
         this.entries.push({
             model,
-            promptTokens: usage.prompt_tokens ?? 0,
-            completionTokens: usage.completion_tokens ?? 0,
-            totalTokens: usage.total_tokens ?? 0,
+            promptTokens,
+            completionTokens,
+            // total_tokens is optional in practice: several OpenAI-compatible
+            // servers send only the two halves. The agent derives it before
+            // emitting 'usage', so the TUI path is covered either way — but this is
+            // a public API, and `?? 0` made a direct caller's totals silently zero
+            // while the split beside them was non-zero. Sum what we were given.
+            totalTokens: usage.total_tokens ?? promptTokens + completionTokens,
             cost: usage.cost ?? 0,
             timestamp: Date.now(),
         });
@@ -38,11 +45,42 @@ export class CostTracker {
             return `${Math.floor(s / 60)}m${s % 60}s`;
         return `${Math.floor(s / 3600)}h${Math.floor((s % 3600) / 60)}m`;
     }
-    summary() {
+    /**
+     * @param provider Which endpoint the session ran against. Only used to say
+     *   where the authoritative charge lives when no cost was reported — the two
+     *   answers are completely different, and pointing a BYOK user at the Scalix
+     *   console would be wrong.
+     */
+    summary(provider) {
+        // A resumed session carries its predecessor's total but not the
+        // prompt/completion split, so the naive line read "Tokens: 12,000 (0
+        // prompt + 0 completion)" — three numbers that contradict each other.
+        // Account for the difference instead of printing zeros.
+        const split = this.promptTokens + this.completionTokens;
+        const carried = this.totalTokens - split;
+        const breakdown = split > 0
+            ? `${this.promptTokens.toLocaleString()} prompt + ${this.completionTokens.toLocaleString()} completion${carried > 0 ? ` + ${carried.toLocaleString()} carried over` : ''}`
+            : 'carried over from a resumed session';
         const lines = [
             `Session: ${this.sessionDuration} | ${this.requestCount} requests`,
-            `Tokens: ${this.totalTokens.toLocaleString()} (${this.promptTokens.toLocaleString()} prompt + ${this.completionTokens.toLocaleString()} completion)`,
+            `Tokens: ${this.totalTokens.toLocaleString()}${this.totalTokens > 0 ? ` (${breakdown})` : ''}`,
         ];
+        // Shown only when the platform actually reported cost (x-scalix-cost-cents
+        // on non-streaming responses) — never a fabricated figure. It's the
+        // platform's estimate; the authoritative charge is computed at billing.
+        if (this.totalCost > 0) {
+            lines.push(`Est. cost: $${this.totalCost.toFixed(4)} (platform estimate — authoritative usage: console.scalix.world → Billing)`);
+        }
+        else if (this.totalTokens > 0) {
+            // A session that used tokens but got no cost header used to print no cost
+            // line at all, which reads as "this was free". It wasn't — the gateway
+            // only attaches x-scalix-cost-cents to non-streaming responses (the
+            // headers are already flushed by the time a stream's usage frame
+            // arrives), so a streamed session simply never learns the figure.
+            lines.push(provider === 'openai'
+                ? 'Est. cost: not reported by your endpoint — check your provider\'s billing dashboard.'
+                : 'Est. cost: not reported on streamed turns — see console.scalix.world → Billing.');
+        }
         const byModel = new Map();
         for (const e of this.entries) {
             if (e.model === '(previous session)')

package/dist/headless.js

@@ -13,8 +13,8 @@ import { loadMcpServices } from './mcp.js';
 import { costTracker } from './cost-tracker.js';
 import { saveSession, loadSession, listSessions, generateSessionId } from './sessions.js';
 import { logger } from './logger.js';
-import { DEFAULT_MODELS, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, ENV_BASE_URL, HEADLESS_DEFAULTS, fetchModelSpecs } from './constants.js';
-import { loadConfig, DEFAULT_LIMITS } from './settings.js';
+import { DEFAULT_MODELS, DEFAULT_INSTRUCTIONS, ENV_MODEL, HEADLESS_DEFAULTS, fetchModelSpecs } from './constants.js';
+import { loadConfig, resolveActiveProvider, DEFAULT_LIMITS } from './settings.js';
 import { checkForUpdate, getUpdateBanner } from './update-checker.js';
 import { getModeDescription, PERMISSION_MODES, setSandboxRoot } from './sandbox.js';
 import { collectGitInfo, gitInfoToContext } from './git-context.js';
@@ -133,16 +133,20 @@ async function buildEnhancedInstructions() {
     return contextToInstructions(base, ctx);
 }
 async function runSinglePrompt(prompt, output, format, outputSchemaPath, beforeExit) {
-    const apiKey = process.env[ENV_API_KEY];
+    const config = await loadConfig();
+    const active = resolveActiveProvider(config);
+    const apiKey = active.apiKey;
     if (!apiKey) {
-        console.error('Error: SCALIX_API_KEY is not set.\nSet it via: export SCALIX_API_KEY=sk-...\nOr run the interactive setup: scalix');
+        console.error(active.provider === 'openai'
+            ? 'Error: no API key for the openai provider.\nSet it via: export OPENAI_API_KEY=sk-...\nOr run the interactive setup: scalix'
+            : 'Error: SCALIX_API_KEY is not set.\nSet it via: export SCALIX_API_KEY=scalix_sk_...\nOr run the interactive setup: scalix');
         process.exit(1);
     }
-    const config = await loadConfig();
     const limits = config.limits || DEFAULT_LIMITS;
-    const baseUrl = process.env[ENV_BASE_URL] || config.baseUrl;
-    // Fetch model specs from API (non-blocking — uses built-in/user-defined as fallback)
-    fetchModelSpecs(baseUrl, apiKey).catch(() => { });
+    const baseUrl = active.baseUrl;
+    // Fetch model specs from API (non-blocking — Scalix-shaped endpoint only)
+    if (active.provider === 'scalix')
+        fetchModelSpecs(baseUrl, apiKey).catch(() => { });
     if (!process.env.NO_UPDATE_NOTIFIER && !config.disableUpdateCheck) {
         checkForUpdate().then(() => {
             const banner = getUpdateBanner();
@@ -189,6 +193,7 @@ async function runSinglePrompt(prompt, output, format, outputSchemaPath, beforeE
     const agent = createAgent({
         apiKey,
         baseUrl,
+        provider: active.provider,
         model: selectedModel,
         instructions,
         tools: allTools,
@@ -300,15 +305,19 @@ async function runPipeMode(beforeExit) {
     await runSinglePrompt(prompt, undefined, undefined, undefined, beforeExit);
 }
 async function runInteractive() {
-    const apiKey = process.env[ENV_API_KEY];
+    const config = await loadConfig();
+    const active = resolveActiveProvider(config);
+    const apiKey = active.apiKey;
     if (!apiKey) {
-        throw new Error('SCALIX_API_KEY is not set. Set it via: export SCALIX_API_KEY=sk-...');
+        throw new Error(active.provider === 'openai'
+            ? 'No API key for the openai provider. Set it via: export OPENAI_API_KEY=sk-...'
+            : 'SCALIX_API_KEY is not set. Set it via: export SCALIX_API_KEY=scalix_sk_...');
     }
-    const config = await loadConfig();
     const limits = config.limits || DEFAULT_LIMITS;
-    const baseUrl = process.env[ENV_BASE_URL] || config.baseUrl;
-    // Fetch model specs from API (non-blocking)
-    fetchModelSpecs(baseUrl, apiKey).catch(() => { });
+    const baseUrl = active.baseUrl;
+    // Fetch model specs from API (non-blocking, Scalix-shaped endpoint only)
+    if (active.provider === 'scalix')
+        fetchModelSpecs(baseUrl, apiKey).catch(() => { });
     const envModels = process.env[ENV_MODEL]
         ? process.env[ENV_MODEL].split(',').map((m) => m.trim()).filter(Boolean)
         : [];
@@ -345,6 +354,7 @@ async function runInteractive() {
     const agent = createAgent({
         apiKey,
         baseUrl,
+        provider: active.provider,
         model: selectedModel,
         instructions,
         tools: allTools,

package/dist/ipc-server.js

@@ -19,10 +19,10 @@ import { visionTools } from './tools-vision.js';
 import { voiceTools } from './tools-voice.js';
 import { browserTools, closeBrowser } from './tools-browser.js';
 import { loadMcpServices } from './mcp.js';
-import { loadConfig, DEFAULT_LIMITS } from './settings.js';
+import { loadConfig, resolveActiveProvider, DEFAULT_LIMITS } from './settings.js';
 import { discoverPlugins, getPluginTools } from './plugins.js';
 import { isWorkspaceTrusted } from './workspace-trust.js';
-import { DEFAULT_MODELS, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, ENV_BASE_URL, fetchModelSpecs } from './constants.js';
+import { DEFAULT_MODELS, DEFAULT_INSTRUCTIONS, ENV_MODEL, fetchModelSpecs, registerUserModels, VERSION } from './constants.js';
 import { loadMemory, autoDetectConventions, saveMemory } from './project-memory.js';
 import { buildProjectContext, contextToInstructions } from './context-builder.js';
 const pendingConfirms = new Map();
@@ -54,9 +54,14 @@ export async function runIpcServer() {
     console.error = (...a) => { process.stderr.write(a.map(String).join(' ') + '\n'); };
     console.warn = (...a) => { process.stderr.write(a.map(String).join(' ') + '\n'); };
     const config = await loadConfig();
-    const apiKey = process.env[ENV_API_KEY] || config.apiKey || '';
+    const active = resolveActiveProvider(config);
+    const apiKey = active.apiKey;
     if (!apiKey) {
-        write({ type: 'event', event: 'error', data: { message: 'SCALIX_API_KEY not set' } });
+        // Keep the SCALIX_API_KEY marker — the VS Code extension keys its
+        // missing-key onboarding branch off this exact string.
+        write({ type: 'event', event: 'error', data: { message: active.provider === 'openai'
+                    ? 'OPENAI_API_KEY not set (provider: openai)'
+                    : 'SCALIX_API_KEY not set' } });
         process.exit(1);
     }
     const limits = config.limits || DEFAULT_LIMITS;
@@ -66,8 +71,9 @@ export async function runIpcServer() {
     const selectedModels = envModels.length > 0
         ? envModels
         : config.models.length > 0 ? config.models : DEFAULT_MODELS;
-    const baseUrl = process.env[ENV_BASE_URL] || config.baseUrl;
-    fetchModelSpecs(baseUrl, apiKey).catch(() => { });
+    const baseUrl = active.baseUrl;
+    if (active.provider === 'scalix')
+        fetchModelSpecs(baseUrl, apiKey).catch(() => { });
     const mcpTools = loadMcpServices();
     // Only discover/load project-local plugins in a trusted workspace — plugins
     // dynamically import and execute code from the project directory.
@@ -102,6 +108,7 @@ export async function runIpcServer() {
     const agent = createAgent({
         apiKey,
         baseUrl,
+        provider: active.provider,
         model: selectedModels,
         instructions,
         tools: allTools,
@@ -129,8 +136,9 @@ export async function runIpcServer() {
     agent.on('error', e => write({ type: 'event', event: 'error', data: { message: e.message } }));
     agent.on('context:compress', i => write({ type: 'event', event: 'context:compress', data: i }));
     agent.on('context:usage', i => write({ type: 'event', event: 'context:usage', data: i }));
-    // Signal ready with capability info
-    write({ type: 'event', event: 'ready', data: { tools: allTools.length, models: selectedModels, permissionMode } });
+    // Signal ready with capability info. `version` lets the extension detect
+    // engine/extension drift (a globally-installed CLI can lag the bundled one).
+    write({ type: 'event', event: 'ready', data: { version: VERSION, tools: allTools.length, models: selectedModels, permissionMode } });
     // Process JSONL from stdin
     let busy = false;
     const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
@@ -201,11 +209,21 @@ export async function runIpcServer() {
                 case 'getModels':
                     write({ type: 'response', id, result: { models: agent.getModels() } });
                     break;
+                case 'registerModels': {
+                    // A model spec added in the client mid-session must reach the agent
+                    // now; the config file is only read at engine start.
+                    const specs = params?.models;
+                    if (specs)
+                        registerUserModels(specs);
+                    write({ type: 'response', id, result: { success: true } });
+                    break;
+                }
                 case 'getContextInfo': {
                     const u = agent.getContextUsage();
                     write({ type: 'response', id, result: {
                             estimatedTokens: u.tokens, maxTokens: u.maxTokens,
                             messageCount: agent.getMessages().length, utilization: u.percentage / 100,
+                            breakdown: agent.getContextBreakdown(),
                         } });
                     break;
                 }

package/dist/keychain.js

@@ -4,9 +4,30 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { USER_CONFIG_DIR } from './constants.js';
-const exec = promisify(execFile);
+const execFileAsync = promisify(execFile);
 const SERVICE = 'scalix-coder';
 const ACCOUNT = 'api-key';
+/**
+ * Ceiling on any single keychain subprocess.
+ *
+ * `security` normally answers in ~20ms, but it is talking to the OS keychain
+ * daemon and that can stall: a locked keychain, or an "allow node to access
+ * this item?" dialog nobody is looking at, blocks the call until it is
+ * answered. Measured on a normal macOS dev machine, one saveConfig() spent
+ * 19.6s in here — and the setup wizard runs it on the final Enter with no
+ * spinner, so that reads as a dead keypress. Nothing here is worth waiting on
+ * for more than a few seconds; the callers all treat failure as "no keychain"
+ * and fall back to the config file.
+ *
+ * Generous rather than snappy on purpose: giving up early would push a working
+ * (just slow) keychain into that plaintext fallback, which is the worse of the
+ * two failures. This is a ceiling on a hang, not a latency target.
+ */
+const KEYCHAIN_TIMEOUT_MS = 20_000;
+/** execFile with a hard timeout, so a stalled keychain can't hang the UI. */
+function exec(file, args, opts = {}) {
+    return execFileAsync(file, args, { timeout: KEYCHAIN_TIMEOUT_MS, killSignal: 'SIGKILL', ...opts });
+}
 /**
  * SCALIX_NO_KEYCHAIN=1 disables OS keychain integration entirely — the API
  * key stays in the config file. Intended for CI, headless environments, and
@@ -23,11 +44,14 @@ async function isMacOS() {
     return process.platform === 'darwin';
 }
 // ─── Windows DPAPI (user-scoped) via PowerShell ───
-function windowsCredentialPath() {
+function windowsCredentialPath(account = ACCOUNT) {
     // Resolve the home directory the same way the rest of the codebase does
     // (settings/sessions/workspace-trust) so the credential store stays
     // consistent and honors HOME (set by Git Bash and by tests).
-    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir() || '.', USER_CONFIG_DIR, 'credential.dat');
+    // The default slot keeps the legacy filename; per-provider slots get a
+    // suffixed file (credential-api-key-openai.dat).
+    const file = account === ACCOUNT ? 'credential.dat' : `credential-${account}.dat`;
+    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir() || '.', USER_CONFIG_DIR, file);
 }
 async function runPowerShell(script, stdinData) {
     const psExe = process.env.SystemRoot
@@ -47,9 +71,9 @@ async function runPowerShell(script, stdinData) {
     const { stdout } = await child;
     return stdout;
 }
-async function setApiKeyWindows(apiKey) {
+async function setApiKeyWindows(apiKey, account = ACCOUNT) {
     try {
-        const credPath = windowsCredentialPath();
+        const credPath = windowsCredentialPath(account);
         await fs.mkdir(path.dirname(credPath), { recursive: true });
         // Read the secret from stdin, encrypt it with user-scoped DPAPI, and print
         // the encrypted string. Reading from stdin avoids putting the secret on the
@@ -67,9 +91,9 @@ async function setApiKeyWindows(apiKey) {
         return false;
     }
 }
-async function getApiKeyWindows() {
+async function getApiKeyWindows(account = ACCOUNT) {
     try {
-        const credPath = windowsCredentialPath();
+        const credPath = windowsCredentialPath(account);
         const encrypted = (await fs.readFile(credPath, 'utf-8')).trim();
         if (!encrypted)
             return null;
@@ -87,9 +111,9 @@ async function getApiKeyWindows() {
         return null;
     }
 }
-async function deleteApiKeyWindows() {
+async function deleteApiKeyWindows(account = ACCOUNT) {
     try {
-        await fs.unlink(windowsCredentialPath());
+        await fs.unlink(windowsCredentialPath(account));
         return true;
     }
     catch {
@@ -107,25 +131,25 @@ async function isLinuxWithSecretTool() {
         return false;
     }
 }
-export async function getApiKeyFromKeychain() {
+export async function getApiKeyFromKeychain(account = ACCOUNT) {
     if (keychainDisabled())
         return null;
     try {
         if (isWindows()) {
-            return await getApiKeyWindows();
+            return await getApiKeyWindows(account);
         }
         if (await isMacOS()) {
             const { stdout } = await exec('security', [
                 'find-generic-password',
                 '-s', SERVICE,
-                '-a', ACCOUNT,
+                '-a', account,
                 '-w',
             ]);
             return stdout.trim() || null;
         }
         if (await isLinuxWithSecretTool()) {
             const { stdout } = await exec('secret-tool', [
-                'lookup', 'service', SERVICE, 'account', ACCOUNT,
+                'lookup', 'service', SERVICE, 'account', account,
             ]);
             return stdout.trim() || null;
         }
@@ -135,12 +159,12 @@ export async function getApiKeyFromKeychain() {
     }
     return null;
 }
-export async function setApiKeyInKeychain(apiKey) {
+export async function setApiKeyInKeychain(apiKey, account = ACCOUNT) {
     if (keychainDisabled())
         return false;
     try {
         if (isWindows()) {
-            return await setApiKeyWindows(apiKey);
+            return await setApiKeyWindows(apiKey, account);
         }
         if (await isMacOS()) {
             // Delete existing entry first (ignore errors if it doesn't exist)
@@ -148,7 +172,7 @@ export async function setApiKeyInKeychain(apiKey) {
                 await exec('security', [
                     'delete-generic-password',
                     '-s', SERVICE,
-                    '-a', ACCOUNT,
+                    '-a', account,
                 ]);
             }
             catch {
@@ -157,7 +181,7 @@ export async function setApiKeyInKeychain(apiKey) {
             await exec('security', [
                 'add-generic-password',
                 '-s', SERVICE,
-                '-a', ACCOUNT,
+                '-a', account,
                 '-w', apiKey,
                 '-U',
             ]);
@@ -168,7 +192,7 @@ export async function setApiKeyInKeychain(apiKey) {
                 'store',
                 '--label', 'Scalix Coder API Key',
                 'service', SERVICE,
-                'account', ACCOUNT,
+                'account', account,
             ]);
             // secret-tool reads the secret from stdin. If stdin isn't available we
             // cannot deliver the secret — treat that as a failure rather than
@@ -188,24 +212,24 @@ export async function setApiKeyInKeychain(apiKey) {
     }
     return false;
 }
-export async function deleteApiKeyFromKeychain() {
+export async function deleteApiKeyFromKeychain(account = ACCOUNT) {
     if (keychainDisabled())
         return false;
     try {
         if (isWindows()) {
-            return await deleteApiKeyWindows();
+            return await deleteApiKeyWindows(account);
         }
         if (await isMacOS()) {
             await exec('security', [
                 'delete-generic-password',
                 '-s', SERVICE,
-                '-a', ACCOUNT,
+                '-a', account,
             ]);
             return true;
         }
         if (await isLinuxWithSecretTool()) {
             await exec('secret-tool', [
-                'clear', 'service', SERVICE, 'account', ACCOUNT,
+                'clear', 'service', SERVICE, 'account', account,
             ]);
             return true;
         }

package/dist/markdown.js

@@ -48,10 +48,27 @@ function createMarked(width) {
         blockquote: chalk.gray.italic,
         del: chalk.dim.strikethrough,
         width,
-        showSectionPrefix: true,
+        // The prefix re-prints the literal '##' in front of every heading, so a
+        // reply that opened with "## Result" reached the screen still wearing its
+        // markdown. chalk.green.bold already marks a heading as a heading.
+        showSectionPrefix: false,
         reflowText: false,
         tab: 2,
     });
+    // marked-terminal 7.3 renders a `text` token as token.text — the raw
+    // markdown source — and never descends into token.tokens. Under marked v15
+    // every tight list item arrives as exactly that token, so "1. a **bold**
+    // point" printed its asterisks while the same emphasis in a paragraph
+    // styled correctly. Parse the children when there are any; leaf text tokens
+    // (the ones parseInline hands back) still go to marked-terminal, so there
+    // is no recursion here.
+    const renderText = mt.renderer.text;
+    mt.renderer.text = function (token) {
+        if (token && typeof token === 'object' && Array.isArray(token.tokens) && token.tokens.length > 0) {
+            return this.parser.parseInline(token.tokens);
+        }
+        return renderText.call(this, token);
+    };
     m.use(mt);
     return m;
 }

package/dist/providers/index.js

@@ -0,0 +1,31 @@
+// Provider layer — BYOK support per MULTI-PROVIDER-ADAPTER-SPEC.md.
+//
+// Scalix is the zero-config default; every other provider is opt-in with the
+// user's own endpoint + key (no hardcoded third-party defaults anywhere).
+// The agent consumes a client (ScalixClient-shaped) plus a capability set that
+// scopes the Scalix-platform workarounds to the scalix provider only.
+import { ScalixClient } from '../api-client.js';
+import { OpenAICompatClient } from './openai.js';
+export const PROVIDER_IDS = ['scalix', 'openai'];
+export function isProviderId(v) {
+    return typeof v === 'string' && PROVIDER_IDS.includes(v);
+}
+const CAPABILITIES = {
+    scalix: { streamingToolCalls: false, maxTokensPolicy: 'clamped', platformTools: true },
+    openai: { streamingToolCalls: true, maxTokensPolicy: 'explicit-only', platformTools: false },
+};
+export function capabilitiesFor(provider) {
+    return CAPABILITIES[provider];
+}
+/** Build the chat client for a provider. baseUrl semantics differ:
+ *  - scalix: API host root (gateway nests /v1/ai) — DEFAULT_BASE_URL applies upstream;
+ *  - openai: the endpoint root of any OpenAI-compatible server, with or
+ *    without its /v1 suffix (api.openai.com/v1, openrouter.ai/api/v1,
+ *    localhost:11434, ...). Required — there is no default third-party URL. */
+export function createChatClient(provider, baseUrl, apiKey) {
+    if (provider === 'openai') {
+        return new OpenAICompatClient(baseUrl, apiKey);
+    }
+    return new ScalixClient(baseUrl, apiKey);
+}
+export { OpenAICompatClient, openaiEndpointRoot } from './openai.js';