scalix 1.4.1 → 1.5.1

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';

package/dist/providers/openai.js

@@ -0,0 +1,149 @@
+// OpenAI-compatible endpoint adapter (BYOK).
+//
+// Speaks the standard OpenAI wire — the same request/response dialect the
+// agent already produces/consumes — against any server that hosts it:
+// OpenAI, OpenRouter, Ollama, LM Studio, Together, vLLM, LiteLLM, ...
+// The only differences from the Scalix client are URL composition
+// ({root}/chat/completions instead of the gateway's /v1/ai nest) and
+// dropping the Scalix-only `thinking_level` field, which strict servers
+// (OpenAI itself) reject as an unrecognized argument.
+import { ScalixClient } from '../api-client.js';
+import { WEB_DEFAULTS } from '../constants.js';
+/**
+ * Normalize a user-supplied OpenAI-compatible base URL to the endpoint root
+ * that `/chat/completions` and `/models` append to. Accepts both conventions:
+ *   https://api.openai.com/v1      → https://api.openai.com/v1
+ *   https://openrouter.ai/api/v1   → https://openrouter.ai/api/v1
+ *   http://localhost:11434         → http://localhost:11434/v1
+ *   http://localhost:1234/         → http://localhost:1234/v1
+ * A versioned path segment anywhere (v1, v2, ...) is treated as already-rooted.
+ */
+export function openaiEndpointRoot(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    try {
+        const u = new URL(trimmed);
+        if (/\/v\d+($|\/)/.test(u.pathname))
+            return trimmed;
+    }
+    catch {
+        // Not parseable as a URL — leave composition to fetch to surface the error.
+        return trimmed;
+    }
+    return `${trimmed}/v1`;
+}
+export class OpenAICompatClient extends ScalixClient {
+    chatUrl() {
+        return `${openaiEndpointRoot(this.baseURL)}/chat/completions`;
+    }
+    modelsUrl() {
+        return openaiModelsUrl(this.baseURL);
+    }
+    /**
+     * The Scalix output ceiling is a property of the Scalix platform, so it must
+     * not be imposed on — or inferred from — someone else's endpoint. The agent
+     * already sends BYOK a max_tokens derived from the user's own model spec (or
+     * none at all), and a third-party server that rejects that value is telling
+     * the user their configuration is wrong: surface it instead of quietly
+     * retrying at a Scalix-shaped number that means nothing here.
+     */
+    canLowerMaxTokens() {
+        return false;
+    }
+    // Deliberately does NOT delegate to super: the base implementation clamps
+    // max_tokens to the Scalix ceiling, which is not this endpoint's business.
+    prepareRequest(req) {
+        let out = req;
+        // `thinking_level` is a Scalix extension; strict OpenAI-compatible servers
+        // 400 on unrecognized arguments. Reasoning output isn't consumed by the
+        // agent today, so dropping it is lossless (spec §3.8).
+        if (out.thinking_level !== undefined) {
+            const { thinking_level: _drop, ...rest } = out;
+            out = rest;
+        }
+        // An OpenAI-compatible server sends a usage chunk on a stream only when it
+        // is asked for. Without this a whole BYOK session streams with no token
+        // figures at all: the status bar, /cost and the context meter all stay on
+        // zero, and the context meter is what tells the user compression is near.
+        // (The Scalix gateway emits a final usage chunk unconditionally, so its
+        // own client has no need of the field.) If the endpoint turns out not to
+        // know `stream_options`, the base client drops it after the first 400 and
+        // sets this flag.
+        if (out.stream && out.stream_options === undefined && !this.streamUsageUnsupported) {
+            out = { ...out, stream_options: { include_usage: true } };
+        }
+        return out;
+    }
+}
+/** The /models URL for an OpenAI-compatible endpoint (OpenAI list shape). */
+export function openaiModelsUrl(baseUrl) {
+    return `${openaiEndpointRoot(baseUrl)}/models`;
+}
+// Everyone agrees on `id` and nobody agrees on the context window: OpenRouter
+// sends context_length, vLLM max_model_len, LM Studio max_context_length,
+// Scalix context_window, and OpenAI itself sends none at all. Read whichever
+// is there; a model that reports nothing keeps contextWindow undefined rather
+// than inheriting someone else's number.
+const CONTEXT_WINDOW_KEYS = ['context_length', 'max_model_len', 'max_context_length', 'context_window'];
+function reportedContextWindow(model) {
+    const top = model.top_provider;
+    for (const source of [model, top]) {
+        if (!source)
+            continue;
+        for (const key of CONTEXT_WINDOW_KEYS) {
+            const v = source[key];
+            if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+                return Math.floor(v);
+        }
+    }
+    return undefined;
+}
+/**
+ * List the models a BYOK endpoint actually serves.
+ *
+ * Without this the setup wizard can only tell the user to go read
+ * `GET /v1/models` themselves and type the ids back in, and one typo produces a
+ * 404 on the first turn with nothing to suggest the id was the problem.
+ *
+ * Deliberately does not touch the model-spec registry: on the Scalix path a
+ * reported spec is the platform's own number, but a third-party endpoint that
+ * reports a context window and no output ceiling would have one invented for
+ * it here, and inventing a ceiling for someone else's model is how you get
+ * rejected requests. The window is returned for the wizard to show and is
+ * never combined with a default.
+ *
+ * Returns [] for anything that isn't a usable answer — this only ever feeds a
+ * picker that the user can bypass by typing an id.
+ */
+export async function fetchByokModels(baseUrl, apiKey) {
+    if (!baseUrl)
+        return [];
+    try {
+        const headers = {};
+        // Ollama and LM Studio serve /models unauthenticated; sending an empty
+        // bearer to an endpoint that does check is a 401 for no reason.
+        if (apiKey)
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        const res = await fetch(openaiModelsUrl(baseUrl), {
+            headers,
+            signal: AbortSignal.timeout(WEB_DEFAULTS.apiFetchTimeoutMs),
+        });
+        if (!res.ok)
+            return [];
+        const body = await res.json();
+        if (!Array.isArray(body.data))
+            return [];
+        const out = [];
+        const seen = new Set();
+        for (const entry of body.data) {
+            const m = entry;
+            if (typeof m?.id !== 'string' || !m.id || seen.has(m.id))
+                continue;
+            seen.add(m.id);
+            out.push({ id: m.id, contextWindow: reportedContextWindow(m) });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/settings.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { setSecurityConfig, setScopedPermissionRules } from './sandbox.js';
-import { DEFAULT_BASE_URL, DEFAULT_MODELS, AGENT_DEFAULTS, CONTEXT_DEFAULTS, WEB_DEFAULTS, TOOL_DEFAULTS, SUB_AGENT_DEFAULTS, MULTI_AGENT_DEFAULTS, USER_CONFIG_DIR, registerUserModels, setNetworkSecurityOverrides, } from './constants.js';
+import { DEFAULT_BASE_URL, DEFAULT_MODELS, AGENT_DEFAULTS, CONTEXT_DEFAULTS, WEB_DEFAULTS, TOOL_DEFAULTS, SUB_AGENT_DEFAULTS, MULTI_AGENT_DEFAULTS, USER_CONFIG_DIR, registerUserModels, setNetworkSecurityOverrides, normalizeModelId, } from './constants.js';
 import { getApiKeyFromKeychain, setApiKeyInKeychain, isKeychainAvailable } from './keychain.js';
+import { isProviderId } from './providers/index.js';
 import { isWorkspaceTrusted } from './workspace-trust.js';
 function getConfigDir() {
     return path.join(process.env.HOME || process.env.USERPROFILE || '.', USER_CONFIG_DIR);
@@ -77,7 +78,7 @@ function validateConfig(parsed) {
     if (typeof parsed.baseUrl === 'string' && parsed.baseUrl.length > 0)
         safe.baseUrl = parsed.baseUrl;
     if (Array.isArray(parsed.models) && parsed.models.every((m) => typeof m === 'string')) {
-        safe.models = parsed.models;
+        safe.models = parsed.models.map(normalizeModelId);
     }
     if (typeof parsed.permissionMode === 'string' && ['plan', 'default', 'auto', 'yolo'].includes(parsed.permissionMode)) {
         safe.permissionMode = parsed.permissionMode;
@@ -90,6 +91,10 @@ function validateConfig(parsed) {
                 typeof s.contextWindow === 'number' && s.contextWindow > 0 &&
                 typeof s.maxOutputTokens === 'number' && s.maxOutputTokens > 0) {
                 validated[id] = { contextWindow: s.contextWindow, maxOutputTokens: s.maxOutputTokens };
+                // Keep the vision flag — dropping it made every user-declared vision
+                // model report supportsVision === false and silently strip images.
+                if (s.supportsVision === true)
+                    validated[id].supportsVision = true;
             }
         }
         if (Object.keys(validated).length > 0) {
@@ -160,6 +165,23 @@ function validateConfig(parsed) {
     if (typeof parsed.disableUpdateCheck === 'boolean') {
         safe.disableUpdateCheck = parsed.disableUpdateCheck;
     }
+    // BYOK (validateConfig drops unknown keys, so these MUST be whitelisted here
+    // or they vanish on the next saveConfig — spec §4 migration gotcha #1).
+    if (isProviderId(parsed.provider)) {
+        safe.provider = parsed.provider;
+    }
+    if (parsed.providers && typeof parsed.providers === 'object' && !Array.isArray(parsed.providers)) {
+        const po = parsed.providers.openai;
+        if (po && typeof po === 'object' && !Array.isArray(po)) {
+            const creds = {};
+            if (typeof po.apiKey === 'string')
+                creds.apiKey = po.apiKey;
+            if (typeof po.baseUrl === 'string' && po.baseUrl.length > 0)
+                creds.baseUrl = po.baseUrl;
+            if (Object.keys(creds).length > 0)
+                safe.providers = { openai: creds };
+        }
+    }
     return safe;
 }
 function isStringArray(val) {
@@ -339,6 +361,12 @@ export async function loadConfig() {
             if (keychainKey)
                 config.apiKey = keychainKey;
         }
+        // Per-provider keychain slot (BYOK): openai key lives under its own account.
+        if (config.providers?.openai && !config.providers.openai.apiKey) {
+            const k = await getApiKeyFromKeychain(OPENAI_KEYCHAIN_ACCOUNT).catch(() => null);
+            if (k)
+                config.providers.openai.apiKey = k;
+        }
         // Apply local overrides (project-level, gitignored)
         config = await loadLocalOverrides(config);
         // Apply managed/organization settings (enterprise policy)
@@ -363,18 +391,99 @@ export async function loadConfig() {
         return config;
     }
 }
+/**
+ * The GLOBAL config file only — no project-local settings.local.json, no
+ * managed-policy merge, no keychain resolution. This is the ONLY correct base
+ * for a read-modify-write persistence cycle: round-tripping loadConfig()
+ * (which merges overrides) through saveConfig() laundered project-local
+ * models/limits/customModels into ~/.scalix-coder/config.json permanently.
+ */
+export async function loadGlobalConfig() {
+    try {
+        const raw = await fs.readFile(getConfigFile(), 'utf-8');
+        return { ...DEFAULTS, ...validateConfig(JSON.parse(raw)) };
+    }
+    catch {
+        return { ...DEFAULTS };
+    }
+}
 export async function saveConfig(config) {
     await ensureDir();
-    // Store API key in keychain if available, strip from config file
+    // Store API keys in keychain if available, strip from config file. The
+    // per-provider secret gets the same blanking treatment as the top-level key
+    // (spec §4: new creds must never persist plaintext when a keychain exists).
     const configToWrite = { ...config };
-    if (config.apiKey && await isKeychainAvailable()) {
-        const stored = await setApiKeyInKeychain(config.apiKey).catch(() => false);
-        if (stored) {
-            configToWrite.apiKey = '';
+    let plaintextSecret = false;
+    if (await isKeychainAvailable()) {
+        if (config.apiKey) {
+            const stored = await setApiKeyInKeychain(config.apiKey).catch(() => false);
+            if (stored)
+                configToWrite.apiKey = '';
+            else
+                plaintextSecret = true;
+        }
+        if (config.providers?.openai?.apiKey) {
+            const stored = await setApiKeyInKeychain(config.providers.openai.apiKey, OPENAI_KEYCHAIN_ACCOUNT).catch(() => false);
+            if (stored) {
+                configToWrite.providers = {
+                    ...configToWrite.providers,
+                    openai: { ...configToWrite.providers.openai, apiKey: '' },
+                };
+            }
+            else {
+                plaintextSecret = true;
+            }
         }
     }
     await fs.writeFile(getConfigFile(), JSON.stringify(configToWrite, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    return { plaintextSecret };
 }
 export function isConfigured(config) {
-    return config.apiKey.length > 0 && config.models.length > 0;
+    const active = resolveActiveProvider(config);
+    if (active.provider === 'scalix') {
+        return config.apiKey.length > 0 && config.models.length > 0;
+    }
+    return active.apiKey.length > 0 && active.baseUrl.length > 0 && config.models.length > 0;
+}
+// ─── BYOK provider resolution ───
+export const OPENAI_KEYCHAIN_ACCOUNT = 'api-key-openai';
+/**
+ * Resolve which provider + credentials this session runs on.
+ *
+ * Precedence (mirrors the rest of config): env → config. `SCALIX_PROVIDER`
+ * selects the provider; for `openai`, `OPENAI_API_KEY` / `OPENAI_BASE_URL`
+ * override `providers.openai`. Scalix stays the zero-config default and its
+ * path is byte-identical to the pre-BYOK behavior. There is NO default
+ * third-party URL — an openai selection without a baseUrl resolves with an
+ * empty one and the caller surfaces the configuration error.
+ *
+ * Scalix Cloud credentials resolve separately so BYOK sessions keep the
+ * platform tools: under `openai` they come from `SCALIX_CLOUD_API_KEY` →
+ * `SCALIX_API_KEY` → the top-level `config.apiKey`, and are simply empty when
+ * the user never added one.
+ */
+export function resolveActiveProvider(config, env = process.env) {
+    const envProvider = env.SCALIX_PROVIDER?.trim().toLowerCase();
+    const provider = isProviderId(envProvider)
+        ? envProvider
+        : (config.provider ?? 'scalix');
+    const scalixBaseUrl = env.SCALIX_BASE_URL?.trim() || config.baseUrl;
+    const scalixApiKey = env.SCALIX_API_KEY?.trim() || config.apiKey;
+    if (provider === 'openai') {
+        const creds = config.providers?.openai ?? {};
+        return {
+            provider,
+            baseUrl: env.OPENAI_BASE_URL?.trim() || creds.baseUrl || '',
+            apiKey: env.OPENAI_API_KEY?.trim() || creds.apiKey || '',
+            cloudBaseUrl: env.SCALIX_CLOUD_BASE_URL?.trim() || scalixBaseUrl,
+            cloudApiKey: env.SCALIX_CLOUD_API_KEY?.trim() || scalixApiKey || '',
+        };
+    }
+    return {
+        provider: 'scalix',
+        baseUrl: scalixBaseUrl,
+        apiKey: scalixApiKey,
+        cloudBaseUrl: scalixBaseUrl,
+        cloudApiKey: scalixApiKey,
+    };
 }