scalix 1.5.2 → 1.6.0

package/dist/marketplace.js

@@ -0,0 +1,400 @@
+/**
+ * Scalix Marketplace client — the curated plugin catalog.
+ *
+ * Coder/Editor/IDE all install the same artifacts (`mcp-services.json`,
+ * `.scalix/skills/`, `.scalix/rules/`, `.scalix/agents/`), and this module is
+ * the one place Coder learns about what the catalog offers and writes it to
+ * disk. The catalog is SERVER data: everything it returns is untrusted input
+ * until validated here, which is why every payload is re-checked client-side
+ * (path traversal, transport shape, credential-looking values) before a
+ * single byte touches the workspace. A compromised backend must not be able
+ * to write outside this project's own config directory.
+ *
+ * Contract: scalix-cloud/docs/MARKETPLACE.md (the crate that serves this is
+ * crates/marketplace). When one changes, the other changes.
+ */
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import { normalizeMcpConfig, validateMcpUrl } from './mcp.js';
+import { logger } from './logger.js';
+/** Same env override the IDE/Editor clients accept, so one variable redirects all three. */
+const DEFAULT_MARKETPLACE_URL = 'https://api.scalix.world/v1/marketplace';
+export function marketplaceBaseUrl(env = process.env) {
+    const override = env.SCALIX_MARKETPLACE_URL?.trim();
+    return (override || DEFAULT_MARKETPLACE_URL).replace(/\/+$/, '');
+}
+const KINDS = ['mcp', 'skill', 'rule', 'subagent'];
+const TRUSTS = ['official', 'verified', 'community'];
+const SURFACES = ['coder', 'ide', 'editor', 'console'];
+/** Size mirror of the server's caps — a listing bigger than this is a bug upstream. */
+const MAX_FILE_BYTES = 256 * 1024;
+const MAX_FILES = 10;
+// ── Client-side validation (server already enforced these; we re-check) ─────
+const LISTING_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const VERSION_RE = /^[0-9]+\.[0-9]+\.[0-9]+([-+][A-Za-z0-9.-_]{0,32})?$/;
+const ENV_RE = /^[A-Z][A-Z0-9_]{0,63}$/;
+const BARE_COMMAND_RE = /^[A-Za-z0-9._@-]{1,64}$/;
+/** Relative path under a listing's install dir: no roots, no traversal, no backslashes. */
+export function isSafeMarketplacePath(rel) {
+    if (!rel || rel.length > 256)
+        return false;
+    if (rel.startsWith('/') || rel.startsWith('\\') || rel.includes('\\'))
+        return false;
+    if (rel.includes('..'))
+        return false;
+    const segments = rel.split('/');
+    if (segments.length > 6)
+        return false;
+    return segments.every(s => s.length > 0 &&
+        s !== '.' &&
+        !s.startsWith('-') &&
+        /^[A-Za-z0-9._ -]+$/.test(s));
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Parse + narrow one API payload into the discriminated union, or null. */
+export function parsePayload(raw) {
+    if (!isPlainRecord(raw))
+        return null;
+    const kind = raw.kind;
+    if (kind === 'mcp') {
+        const transport = raw.transport;
+        if (transport !== 'http' && transport !== 'stdio')
+            return null;
+        if (typeof raw.serverLabel !== 'string' || raw.serverLabel.length < 2)
+            return null;
+        const payload = { kind: 'mcp', transport, serverLabel: raw.serverLabel };
+        if (transport === 'http') {
+            // Catalog contract is STRICTER than a hand-written config: https only
+            // (validateMcpUrl itself allows plain http for local servers), plus the
+            // shared SSRF/private-host guard — a compromised backend must not be
+            // able to aim a "curated" entry at 169.254.169.254 with our headers.
+            if (typeof raw.serverUrl !== 'string')
+                return null;
+            if (!raw.serverUrl.startsWith('https://'))
+                return null;
+            const blocked = validateMcpUrl(raw.serverUrl);
+            if (blocked)
+                return null;
+            payload.serverUrl = raw.serverUrl;
+            if (raw.authorizationEnv !== undefined) {
+                if (typeof raw.authorizationEnv !== 'string' || !ENV_RE.test(raw.authorizationEnv))
+                    return null;
+                payload.authorizationEnv = raw.authorizationEnv;
+            }
+        }
+        else {
+            if (typeof raw.command !== 'string' || !BARE_COMMAND_RE.test(raw.command))
+                return null;
+            payload.command = raw.command;
+            if (raw.args !== undefined) {
+                if (!Array.isArray(raw.args) || raw.args.some(a => typeof a !== 'string' || a.length > 512))
+                    return null;
+                payload.args = raw.args;
+            }
+        }
+        if (raw.headers !== undefined) {
+            if (!isPlainRecord(raw.headers))
+                return null;
+            const headers = {};
+            for (const [k, v] of Object.entries(raw.headers)) {
+                if (typeof v !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(k))
+                    return null;
+                headers[k] = v;
+            }
+            payload.headers = headers;
+        }
+        if (raw.requiredEnv !== undefined) {
+            if (!Array.isArray(raw.requiredEnv))
+                return null;
+            const names = [];
+            for (const name of raw.requiredEnv) {
+                if (typeof name !== 'string' || !ENV_RE.test(name))
+                    return null;
+                names.push(name);
+            }
+            payload.requiredEnv = names;
+        }
+        return payload;
+    }
+    if (kind === 'skill') {
+        if (typeof raw.name !== 'string' || raw.name.length < 2)
+            return null;
+        if (!Array.isArray(raw.files) || raw.files.length === 0 || raw.files.length > MAX_FILES)
+            return null;
+        const files = [];
+        for (const file of raw.files) {
+            if (!isPlainRecord(file) || typeof file.path !== 'string' || typeof file.content !== 'string')
+                return null;
+            if (!isSafeMarketplacePath(file.path))
+                return null;
+            if (file.content.length > MAX_FILE_BYTES)
+                return null;
+            files.push({ path: file.path, content: file.content });
+        }
+        if (!files.some(f => f.path === 'SKILL.md'))
+            return null;
+        return { kind: 'skill', name: raw.name, files };
+    }
+    if (kind === 'rule' || kind === 'subagent') {
+        if (typeof raw.fileName !== 'string' || !raw.fileName.endsWith('.md'))
+            return null;
+        if (!isSafeMarketplacePath(raw.fileName))
+            return null;
+        if (typeof raw.content !== 'string' || !raw.content || raw.content.length > MAX_FILE_BYTES)
+            return null;
+        return { kind, fileName: raw.fileName, content: raw.content };
+    }
+    return null;
+}
+function parseSummary(raw) {
+    if (!isPlainRecord(raw))
+        return null;
+    const { id, kind, name, summary } = raw;
+    if (typeof id !== 'string' || !LISTING_ID_RE.test(id))
+        return null;
+    if (typeof kind !== 'string' || !KINDS.includes(kind))
+        return null;
+    if (typeof name !== 'string' || !name)
+        return null;
+    if (typeof summary !== 'string')
+        return null;
+    const trust = typeof raw.trust === 'string' && TRUSTS.includes(raw.trust)
+        ? raw.trust
+        : 'community';
+    const arrayOf = (value) => Array.isArray(value) ? value.filter((v) => typeof v === 'string') : [];
+    return {
+        id,
+        kind: kind,
+        name,
+        summary,
+        author: typeof raw.author === 'string' ? raw.author : '',
+        trust,
+        install_count: typeof raw.install_count === 'number' ? raw.install_count : 0,
+        version: typeof raw.version === 'string' ? raw.version : '',
+        featured: raw.featured === true,
+        categories: arrayOf(raw.categories),
+        tags: arrayOf(raw.tags),
+    };
+}
+// ── API ─────────────────────────────────────────────────────────────────────
+async function fetchJson(url, timeoutMs = 10_000) {
+    const response = await fetch(url, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok) {
+        throw new Error(`marketplace responded ${response.status}`);
+    }
+    return response.json();
+}
+export async function listMarketplaceListings(options = {}) {
+    const base = options.baseUrl ?? marketplaceBaseUrl();
+    const params = new URLSearchParams();
+    if (options.q)
+        params.set('q', options.q);
+    if (options.kind)
+        params.set('kind', options.kind);
+    params.set('limit', String(Math.min(Math.max(options.limit ?? 50, 1), 100)));
+    if (options.offset)
+        params.set('offset', String(options.offset));
+    const body = await fetchJson(`${base}/listings?${params.toString()}`);
+    if (!isPlainRecord(body) || !Array.isArray(body.listings)) {
+        throw new Error('marketplace returned an unexpected listings payload');
+    }
+    const parsed = [];
+    for (const entry of body.listings) {
+        const summary = parseSummary(entry);
+        if (summary)
+            parsed.push(summary);
+    }
+    return parsed;
+}
+export async function getMarketplaceListing(id, baseUrl) {
+    if (!LISTING_ID_RE.test(id))
+        throw new Error(`invalid marketplace listing id: ${id}`);
+    const base = baseUrl ?? marketplaceBaseUrl();
+    const raw = await fetchJson(`${base}/listings/${encodeURIComponent(id)}`);
+    const summary = parseSummary(raw);
+    if (!summary || !isPlainRecord(raw))
+        throw new Error('marketplace returned an unexpected listing payload');
+    const detail = {
+        ...summary,
+        description: typeof raw.description === 'string' ? raw.description : '',
+        homepage_url: typeof raw.homepage_url === 'string' ? raw.homepage_url : '',
+        icon_url: typeof raw.icon_url === 'string' ? raw.icon_url : '',
+        payload: parsePayload(raw.payload),
+    };
+    return detail;
+}
+/** Best-effort anonymous telemetry. Never fails an install. */
+export async function reportMarketplaceInstall(detail, surface = 'coder') {
+    try {
+        if (!SURFACES.includes(surface))
+            return;
+        if (!LISTING_ID_RE.test(detail.id) || !VERSION_RE.test(detail.version))
+            return;
+        await fetch(`${marketplaceBaseUrl()}/installs`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ listing_id: detail.id, version: detail.version, surface }),
+            signal: AbortSignal.timeout(5_000),
+        });
+    }
+    catch (err) {
+        logger.debug(`marketplace install telemetry skipped: ${err?.message ?? err}`);
+    }
+}
+// ── Install ─────────────────────────────────────────────────────────────────
+const MCP_CONFIG = 'mcp-services.json';
+async function readWorkspaceFile(rel) {
+    try {
+        return await fs.readFile(path.resolve(rel), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Merge one MCP entry into `mcp-services.json`, preserving every existing
+ * server (through normalizeMcpConfig, so the object-map dialect the IDE panel
+ * writes survives). Returns the relative path touched.
+ */
+async function installMcpEntry(payload, options) {
+    const configPath = path.resolve(options.cwd ?? process.cwd(), MCP_CONFIG);
+    let config = { mcpServers: [] };
+    const existing = await readWorkspaceFile(configPath);
+    if (existing) {
+        const parsed = normalizeMcpConfig(JSON.parse(existing));
+        config.mcpServers = Array.isArray(parsed?.mcpServers) ? parsed.mcpServers : [];
+    }
+    const entry = { serverLabel: payload.serverLabel };
+    if (payload.transport === 'http') {
+        const blocked = validateMcpUrl(payload.serverUrl);
+        if (blocked) {
+            return { success: false, message: '', paths: [], error: `refused marketplace MCP URL: ${blocked}` };
+        }
+        entry.serverUrl = payload.serverUrl;
+        if (payload.authorizationEnv)
+            entry.authorizationEnv = payload.authorizationEnv;
+        if (payload.headers && Object.keys(payload.headers).length > 0)
+            entry.headers = payload.headers;
+    }
+    else {
+        // A stdio entry spawns a local process — the caller must have confirmed
+        // explicitly (the slash command asks; the agent tool refuses without it).
+        if (!options.confirmStdio) {
+            return {
+                success: false,
+                message: '',
+                paths: [],
+                error: 'this listing installs a local MCP server (stdio) — re-run with explicit confirmation',
+            };
+        }
+        entry.command = payload.command;
+        entry.args = payload.args ?? [];
+    }
+    if (config.mcpServers.some(s => s?.serverLabel === payload.serverLabel)) {
+        return {
+            success: false,
+            message: '',
+            paths: [],
+            error: `an MCP server labelled "${payload.serverLabel}" is already configured`,
+        };
+    }
+    config.mcpServers.push(entry);
+    config.mcpServers = config.mcpServers.filter((s) => Boolean(s));
+    await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+    const envNote = payload.requiredEnv?.length
+        ? ` Set ${payload.requiredEnv.join(', ')} in your environment before restarting the session.`
+        : '';
+    return {
+        success: true,
+        message: `Added MCP server ${payload.serverLabel} to ${MCP_CONFIG} (restart or /mcp to connect).${envNote}`,
+        paths: [MCP_CONFIG],
+    };
+}
+/** Write a listing's files under its install directory, re-validating every path. */
+async function writeListingFiles(files, targetDir, workspaceCwd) {
+    const written = [];
+    const resolvedTarget = path.resolve(targetDir);
+    for (const file of files) {
+        if (!isSafeMarketplacePath(file.path)) {
+            throw new Error(`refusing unsafe install path: ${file.path}`);
+        }
+        const target = path.resolve(resolvedTarget, file.path);
+        if (!target.startsWith(resolvedTarget + path.sep)) {
+            throw new Error(`refusing path outside the install directory: ${file.path}`);
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, file.content, 'utf-8');
+        written.push(path.relative(workspaceCwd, target));
+    }
+    return written;
+}
+/**
+ * Install one listing into the current workspace. Nothing here can write
+ * outside the workspace: every path is re-validated, and every target lives
+ * under the project's own `.scalix/` directory or the root MCP config.
+ */
+export async function installMarketplaceListing(detail, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!detail.payload) {
+        return { success: false, message: '', paths: [], error: 'listing has no installable payload' };
+    }
+    try {
+        switch (detail.payload.kind) {
+            case 'mcp':
+                return await installMcpEntry(detail.payload, { ...options, cwd });
+            case 'skill': {
+                if (!detail.payload.files.some(f => f.path === 'SKILL.md')) {
+                    return { success: false, message: '', paths: [], error: 'skill payload has no SKILL.md' };
+                }
+                const dir = path.join(cwd, '.scalix', 'skills', detail.payload.name);
+                const paths = await writeListingFiles(detail.payload.files, dir, cwd);
+                return { success: true, message: `Installed skill ${detail.payload.name} (${paths.join(', ')})`, paths };
+            }
+            case 'rule':
+            case 'subagent': {
+                const subdir = detail.payload.kind === 'rule' ? 'rules' : 'agents';
+                const dir = path.join(cwd, '.scalix', subdir);
+                await fs.mkdir(dir, { recursive: true });
+                const paths = await writeListingFiles([{ path: detail.payload.fileName, content: detail.payload.content }], dir, cwd);
+                return {
+                    success: true,
+                    message: `Installed ${detail.payload.kind} ${detail.payload.fileName} (${paths.join(', ')})`,
+                    paths,
+                };
+            }
+        }
+    }
+    catch (err) {
+        return { success: false, message: '', paths: [], error: err?.message ?? String(err) };
+    }
+}
+/** Convenience: fetch a listing, install it, and report telemetry (best effort). */
+export async function installFromMarketplace(listingId, options = {}) {
+    const detail = await getMarketplaceListing(listingId);
+    const result = await installMarketplaceListing(detail, options);
+    if (result.success)
+        await reportMarketplaceInstall(detail);
+    return result;
+}
+export { KINDS as MARKETPLACE_KINDS, TRUSTS as MARKETPLACE_TRUSTS };
+/** True when the workspace already has an MCP server under this label. */
+export function hasMcpLabel(cwd, label) {
+    const configPath = path.resolve(cwd, MCP_CONFIG);
+    if (!fsSync.existsSync(configPath))
+        return false;
+    try {
+        const parsed = normalizeMcpConfig(JSON.parse(fsSync.readFileSync(configPath, 'utf-8')));
+        if (!Array.isArray(parsed?.mcpServers))
+            return false;
+        return parsed.mcpServers.some((s) => s?.serverLabel === label);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/mcp.js

@@ -21,7 +21,7 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import dns from 'node:dns';
+import { resolveLookupAddresses, pinnedFetch } from './secure-fetch.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
@@ -109,7 +109,7 @@ export function loadMcpConfig(configPath = 'mcp-services.json') {
             // Server READMEs ship example URLs; connecting to them just produces a
             // confusing timeout, so drop them before we ever dial.
             if (url.includes('example.com') || url.includes('your-') || url.includes('placeholder')) {
-                logger.warn(`Skipping MCP "${s.serverLabel}": placeholder URL detected`, { url: s.serverUrl });
+                logger.warn(`Skipping MCP "${s.serverLabel}": placeholder URL detected`, { url: redactUrl(s.serverUrl) });
                 return false;
             }
             return true;
@@ -148,22 +148,38 @@ export function validateMcpUrl(rawUrl) {
     }
     return null;
 }
-/** Post-DNS half of the check: defeats a public name resolving inward. */
-async function resolvesPrivate(hostname) {
+/**
+ * URL safe for logs: strip userinfo (`https://user:token@host` →
+ * `https://host`) so credentials embedded in a serverUrl never reach the log.
+ */
+function redactUrl(rawUrl) {
     try {
-        const addresses = await dns.promises.lookup(hostname, { all: true });
-        // isPrivateHost rather than isPrivateIp: for a literal address the two
-        // agree, but only the former honours security.allowedPrivateHosts, so an
-        // operator who deliberately allowed a private MCP host is not blocked one
-        // step later by the rebinding check they never asked for.
-        if (addresses.some((a) => isPrivateHost(a.address))) {
-            return 'hostname resolves to a private network address';
-        }
+        const url = new URL(rawUrl);
+        if (!url.username && !url.password)
+            return rawUrl;
+        url.username = '';
+        url.password = '';
+        return url.href;
     }
     catch {
-        // A DNS failure is the dial's problem to report, not a reason to block.
+        return rawUrl;
     }
-    return null;
+}
+/** Post-DNS half of the check: defeats a public name resolving inward.
+ *  The validated addresses are returned so the dial can be pinned to them —
+ *  validating one resolution and connecting on another is the rebinding hole
+ *  itself (see secure-fetch.ts). */
+async function resolvesPrivate(hostname) {
+    const addresses = await resolveLookupAddresses(hostname);
+    // isPrivateHost rather than isPrivateIp: for a literal address the two
+    // agree, but only the former honours security.allowedPrivateHosts, so an
+    // operator who deliberately allowed a private MCP host is not blocked one
+    // step later by the rebinding check they never asked for.
+    if (addresses.length > 0 && addresses.some((a) => isPrivateHost(a.address))) {
+        return { blocked: 'hostname resolves to a private network address', addresses: [] };
+    }
+    // A DNS failure is the dial's problem to report, not a reason to block.
+    return { blocked: null, addresses };
 }
 /**
  * The fetch both remote transports run on.
@@ -178,10 +194,13 @@ async function mcpFetch(input, init) {
     let current = new URL(typeof input === 'string' ? input : input.toString());
     let headers = new Headers(init?.headers);
     for (let hop = 0;; hop++) {
-        const blocked = validateMcpUrl(current.href) ?? (await resolvesPrivate(current.hostname));
+        const urlBlocked = validateMcpUrl(current.href);
+        if (urlBlocked)
+            throw new Error(`Blocked MCP request: ${urlBlocked}`);
+        const { blocked, addresses } = await resolvesPrivate(current.hostname);
         if (blocked)
             throw new Error(`Blocked MCP request: ${blocked}`);
-        const response = await fetch(current.href, { ...init, headers, redirect: 'manual' });
+        const response = await pinnedFetch(current, { ...init, headers, redirect: 'manual' }, addresses);
         if (response.status < 300 || response.status >= 400)
             return response;
         const location = response.headers.get('location');
@@ -190,12 +209,20 @@ async function mcpFetch(input, init) {
         if (hop >= MAX_MCP_REDIRECTS) {
             throw new Error(`Blocked MCP request: too many redirects (>${MAX_MCP_REDIRECTS})`);
         }
+        // 301/302/303 on a request with a body switch to GET and drop the body per
+        // the fetch spec; 307/308 keep method and body. Replaying a POST body to
+        // the redirect target would leak it cross-origin.
+        let nextInit = init;
+        if ((response.status === 301 || response.status === 302 || response.status === 303) && init?.method && init.method.toUpperCase() !== 'GET' && init.method.toUpperCase() !== 'HEAD') {
+            nextInit = { ...init, method: 'GET', body: undefined };
+        }
         const next = new URL(location, current);
         if (next.origin !== current.origin) {
             headers = new Headers(headers);
             headers.delete('authorization');
         }
         current = next;
+        init = nextInit;
     }
 }
 function resolveAuthorization(config) {
@@ -371,7 +398,7 @@ export class McpHub {
             const error = 'MCP servers are only started in a trusted workspace';
             logger.warn(`Skipping MCP "${label}": ${error}`, {
                 transport: kindOf(),
-                target: isStdioService(config) ? config.command : config.serverUrl,
+                target: isStdioService(config) ? config.command : redactUrl(config.serverUrl),
             });
             return { label, transport: kindOf(), state: 'skipped', toolCount: 0, error };
         }
@@ -379,7 +406,7 @@ export class McpHub {
             const blocked = validateMcpUrl(config.serverUrl);
             if (blocked) {
                 const error = `refusing to connect: ${blocked}`;
-                logger.warn(`Skipping MCP "${label}": ${error}`, { url: config.serverUrl });
+                logger.warn(`Skipping MCP "${label}": ${error}`, { url: redactUrl(config.serverUrl) });
                 return { label, transport: kindOf(), state: 'skipped', toolCount: 0, error };
             }
         }

package/dist/providers/index.js

@@ -4,26 +4,43 @@
 // 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.
+//
+// A provider KEY (e.g. `scalix`, `openai`, `novita`, `local-ollama`) names a
+// configured registry entry; an ADAPTER (`scalix` | `openai`) picks the wire
+// dialect and, with it, the capability set. Every non-scalix key speaks the
+// OpenAI-compatible wire, so new BYOK providers need no code — only config.
 import { ScalixClient } from '../api-client.js';
 import { OpenAICompatClient } from './openai.js';
+/** Built-in provider keys. Any other key is a user-defined BYOK provider. */
 export const PROVIDER_IDS = ['scalix', 'openai'];
+const PROVIDER_KEY_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
+/** A syntactically usable provider key. Unknown keys are allowed on purpose:
+ *  the registry (config.providers) is the source of truth for what exists. */
 export function isProviderId(v) {
+    return typeof v === 'string' && PROVIDER_KEY_RE.test(v);
+}
+export function isBuiltInProviderId(v) {
     return typeof v === 'string' && PROVIDER_IDS.includes(v);
 }
+/** Resolve the wire dialect for a provider key. Scalix is the only special
+ *  case; everything else is OpenAI-compatible. */
+export function adapterFor(provider) {
+    return provider === 'scalix' ? 'scalix' : 'openai';
+}
 const CAPABILITIES = {
     scalix: { streamingToolCalls: false, maxTokensPolicy: 'clamped', platformTools: true },
     openai: { streamingToolCalls: true, maxTokensPolicy: 'explicit-only', platformTools: false },
 };
 export function capabilitiesFor(provider) {
-    return CAPABILITIES[provider];
+    return CAPABILITIES[adapterFor(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,
+ *  - openai-compatible: 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') {
+    if (adapterFor(provider) === 'openai') {
         return new OpenAICompatClient(baseUrl, apiKey);
     }
     return new ScalixClient(baseUrl, apiKey);