@megacode/cli 0.2.0

package/dist/adapters/git/worktree.js

@@ -0,0 +1,113 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, realpath, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { loadSettings } from "../settings.js";
+export const WORKTREE_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+const execGit = promisify(execFile);
+// Async so a slow git (large repo, network filesystem) never freezes the UI.
+async function git(cwd, ...args) {
+    return (await execGit("git", args, { cwd, encoding: "utf8" })).stdout.trim();
+}
+const tryGit = (cwd, ...args) => git(cwd, ...args).catch(() => null);
+/** git's own message for a failed command. */
+const gitError = (e) => e.stderr?.trim() || e.message;
+/** Root of the main checkout, also when called from inside a worktree. */
+export async function mainRoot(cwd = process.cwd()) {
+    const common = await tryGit(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir");
+    if (!common)
+        throw new Error("Not a git repository; worktrees need git.");
+    return path.dirname(common);
+}
+const worktreesDir = (root) => path.join(root, ".megacode", "worktrees");
+const worktree = (root, name) => ({
+    name,
+    path: path.join(worktreesDir(root), name),
+    branch: `worktree-${name}`,
+    root,
+});
+/** Worktrees under .megacode/worktrees that git knows about. */
+export async function listWorktrees(cwd = process.cwd()) {
+    const root = await mainRoot(cwd);
+    const dir = worktreesDir(root);
+    if (!existsSync(dir))
+        return [];
+    const real = await realpath(dir);
+    return (await git(root, "worktree", "list", "--porcelain"))
+        .split("\n")
+        .filter((l) => l.startsWith("worktree "))
+        .map((l) => l.slice("worktree ".length))
+        .filter((p) => path.dirname(p) === real || path.dirname(p) === dir)
+        .map((p) => worktree(root, path.basename(p)));
+}
+const ADJECTIVES = ["brisk", "calm", "clever", "eager", "gentle", "happy", "keen", "lucky", "nimble", "quiet", "swift", "witty"];
+const NOUNS = ["badger", "comet", "falcon", "harbor", "lantern", "maple", "otter", "pebble", "river", "sparrow", "tiger", "willow"];
+const pick = (list) => list[Math.floor(Math.random() * list.length)];
+function randomName(root) {
+    for (;;) {
+        const name = `${pick(ADJECTIVES)}-${pick(NOUNS)}-${Math.floor(Math.random() * 1000)}`;
+        if (!existsSync(worktree(root, name).path))
+            return name;
+    }
+}
+/** The commit new worktrees start from: the remote's default branch, or the current commit (see /config). */
+export async function baseRef(cwd = process.cwd()) {
+    if (loadSettings().worktreeBase === "fresh")
+        for (const ref of ["origin/HEAD", "origin/main", "origin/master"])
+            if (await tryGit(cwd, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`))
+                return ref;
+    return "HEAD";
+}
+/** Opens the worktree with this name, creating it (and its branch) if needed. No name picks a random one. */
+export async function openWorktree(name, cwd = process.cwd()) {
+    const root = await mainRoot(cwd);
+    if (name !== undefined && !WORKTREE_NAME.test(name))
+        throw new Error(`Invalid worktree name "${name}": use letters, digits, - and _ (max 64).`);
+    const wt = worktree(root, name ?? randomName(root));
+    if ((await listWorktrees(root)).some((w) => w.name === wt.name))
+        return { ...wt, created: false };
+    if (existsSync(wt.path))
+        throw new Error(`${wt.path} exists but isn't a git worktree; remove it or pick another name.`);
+    // Keep worktrees out of the main checkout's `git status`.
+    await mkdir(worktreesDir(root), { recursive: true });
+    const ignore = path.join(worktreesDir(root), ".gitignore");
+    if (!existsSync(ignore))
+        await writeFile(ignore, "*\n");
+    // Reuse a branch left behind by an earlier worktree of the same name rather than resetting it.
+    const branchExists = await tryGit(root, "rev-parse", "--verify", "--quiet", `refs/heads/${wt.branch}`);
+    const args = branchExists ? [wt.path, wt.branch] : ["-b", wt.branch, wt.path, await baseRef(cwd)];
+    await git(root, "worktree", "add", ...args).catch((e) => {
+        throw new Error(`git worktree add failed: ${gitError(e)}`);
+    });
+    return { ...wt, created: true };
+}
+/** Uncommitted files, and commits on the worktree's branch that no other branch or remote has. Null if git fails. */
+export async function worktreeChanges(wt) {
+    const [status, commits] = await Promise.all([
+        tryGit(wt.path, "status", "--porcelain"),
+        tryGit(wt.path, "rev-list", "--count", "HEAD", "--not", `--exclude=${wt.branch}`, "--branches", "--remotes"),
+    ]);
+    if (status === null || commits === null)
+        return null;
+    return { files: status.split("\n").filter(Boolean).length, commits: Number(commits) };
+}
+export function describeChanges(c) {
+    if (!c)
+        return "status unknown";
+    const parts = [];
+    if (c.files)
+        parts.push(`${c.files} changed file${c.files === 1 ? "" : "s"}`);
+    if (c.commits)
+        parts.push(`${c.commits} new commit${c.commits === 1 ? "" : "s"}`);
+    return parts.join(", ") || "no changes";
+}
+/** Deletes the worktree directory (discarding uncommitted changes) and its branch. */
+export async function removeWorktree(wt) {
+    if (process.cwd() === wt.path || process.cwd().startsWith(wt.path + path.sep))
+        process.chdir(wt.root);
+    await git(wt.root, "worktree", "remove", "--force", wt.path).catch((e) => {
+        throw new Error(`git worktree remove failed: ${gitError(e)}`);
+    });
+    await tryGit(wt.root, "branch", "-D", wt.branch);
+}

package/dist/adapters/mcp/config.js

@@ -0,0 +1,59 @@
+import { readJson, writeJson } from "../storage.js";
+export const MCP_FILE = "mcp.json";
+export const SERVER_NAME = /^[A-Za-z0-9_-]{1,32}$/;
+export const loadServers = () => readJson(MCP_FILE, {}).mcpServers ?? {};
+/** Writes the server list, keeping any other keys in the file. */
+export function saveServers(servers) {
+    writeJson(MCP_FILE, { ...readJson(MCP_FILE, {}), mcpServers: servers });
+}
+export const transportOf = (c) => ("url" in c ? c.type : "stdio");
+export const describeServer = (c) => ("url" in c ? c.url : [c.command, ...(c.args ?? [])].join(" "));
+/** Draft → config: `target` is a URL for http/sse, else a command line; `extras` are headers or env vars. */
+export function draftToConfig({ type, target, extras }) {
+    const hasExtras = Object.keys(extras).length > 0;
+    if (type !== "stdio")
+        return { type, url: target, ...(hasExtras ? { headers: extras } : {}) };
+    const [command, ...args] = splitCommand(target);
+    return { command: command, args, ...(hasExtras ? { env: extras } : {}) };
+}
+/** Parses "Name: value" (a header) or "KEY=value" (an env var). Null if malformed. */
+export function parseExtra(type, line) {
+    const m = type === "stdio" ? line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s) : line.match(/^([^:\s]+):\s*(.+)$/);
+    return m ? [m[1], m[2]] : null;
+}
+export function isHttpUrl(text) {
+    try {
+        return /^https?:$/.test(new URL(text).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+/** Splits a command line into words, honoring single and double quotes. */
+export function splitCommand(line) {
+    const words = [];
+    let word = null;
+    let quote = null;
+    for (const ch of line) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                word += ch;
+        }
+        else if (ch === "'" || ch === '"') {
+            quote = ch;
+            word ??= "";
+        }
+        else if (/\s/.test(ch)) {
+            if (word !== null)
+                words.push(word);
+            word = null;
+        }
+        else
+            word = (word ?? "") + ch;
+    }
+    if (word !== null)
+        words.push(word);
+    return words;
+}

package/dist/adapters/mcp/manager.js

@@ -0,0 +1,165 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+import { withTimeout } from "../../lib/async.js";
+import { compactOutput } from "../tools/output.js";
+import { loadServers, saveServers } from "./config.js";
+import { formatResult } from "./results.js";
+import { createTransport } from "./transport.js";
+const CONNECT_TIMEOUT = 30_000;
+const CALL_TIMEOUT = 10 * 60_000;
+/** Tool names must match ^[A-Za-z0-9_-]{1,64}$ for every provider. */
+const toolName = (server, tool) => `mcp__${server}__${tool.replace(/[^A-Za-z0-9_-]/g, "_")}`.slice(0, 64);
+const lastLine = (s) => s.trim().split("\n").at(-1)?.slice(0, 300) ?? "";
+/** Connections to the servers in ~/.megacode/mcp.json, offered to the agent as a ToolSource. */
+export class McpManager {
+    status = new Map();
+    connections = new Map();
+    generation = new Map(); // ignore events from superseded connections
+    listeners = new Set();
+    /** Re-render hook for the UI. Returns an unsubscribe function. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => void this.listeners.delete(listener);
+    }
+    set(name, status) {
+        if (status)
+            this.status.set(name, status);
+        else
+            this.status.delete(name);
+        for (const l of this.listeners)
+            l();
+    }
+    servers() {
+        return Object.entries(loadServers()).map(([name, config]) => ({
+            name,
+            config,
+            status: config.disabled ? { state: "disabled" } : (this.status.get(name) ?? { state: "connecting" }),
+        }));
+    }
+    /** Connects every enabled server. Resolves once each has connected or failed. */
+    start() {
+        return Promise.all(this.servers().filter((s) => !s.config.disabled).map((s) => this.connect(s.name)));
+    }
+    async connect(name) {
+        const config = loadServers()[name];
+        await this.disconnect(name);
+        if (!config)
+            return { state: "failed", error: "not configured" };
+        if (config.disabled)
+            return { state: "disabled" };
+        const gen = this.bumpGeneration(name);
+        const current = () => this.generation.get(name) === gen;
+        this.set(name, { state: "connecting" });
+        const { transport, stderr } = createTransport(config);
+        const conn = { client: new Client({ name: "megacode", version: "1.0.0" }), stderr };
+        this.connections.set(name, conn);
+        try {
+            await withTimeout(conn.client.connect(transport).then(() => this.refreshTools(name, conn, gen)), CONNECT_TIMEOUT, "timed out connecting");
+            conn.client.setNotificationHandler(ToolListChangedNotificationSchema, () => this.refreshTools(name, conn, gen).catch(() => { }));
+            conn.client.onclose = () => {
+                if (!current())
+                    return;
+                this.connections.delete(name);
+                this.set(name, { state: "failed", error: lastLine(stderr()) || "connection closed" });
+            };
+        }
+        catch (e) {
+            if (current()) {
+                await this.disconnect(name);
+                this.set(name, { state: "failed", error: [e.message, lastLine(stderr())].filter(Boolean).join(" · ") });
+            }
+        }
+        return this.status.get(name);
+    }
+    async refreshTools(name, conn, gen) {
+        const tools = [];
+        let cursor;
+        do {
+            const page = await conn.client.listTools(cursor ? { cursor } : undefined);
+            for (const t of page.tools)
+                tools.push({
+                    name: toolName(name, t.name),
+                    server: name,
+                    tool: t.name,
+                    description: t.description ?? t.title ?? t.name,
+                    parameters: { ...t.inputSchema, type: "object", properties: t.inputSchema.properties ?? {} },
+                });
+            cursor = page.nextCursor;
+        } while (cursor);
+        if (this.generation.get(name) === gen)
+            this.set(name, { state: "connected", tools, instructions: conn.client.getInstructions() });
+    }
+    bumpGeneration(name) {
+        const gen = (this.generation.get(name) ?? 0) + 1;
+        this.generation.set(name, gen);
+        return gen;
+    }
+    async disconnect(name) {
+        const conn = this.connections.get(name);
+        this.connections.delete(name);
+        this.bumpGeneration(name);
+        await conn?.client.close().catch(() => { });
+    }
+    add(name, config) {
+        saveServers({ ...loadServers(), [name]: config });
+        return this.connect(name);
+    }
+    async remove(name) {
+        const { [name]: _, ...rest } = loadServers();
+        saveServers(rest);
+        await this.disconnect(name);
+        this.set(name, null);
+    }
+    async setEnabled(name, enabled) {
+        const servers = loadServers();
+        if (!servers[name])
+            return;
+        const { disabled: _, ...config } = servers[name];
+        saveServers({ ...servers, [name]: enabled ? config : { ...config, disabled: true } });
+        if (enabled)
+            return void (await this.connect(name));
+        await this.disconnect(name);
+        this.set(name, { state: "disabled" });
+    }
+    closeAll() {
+        return Promise.all([...this.connections.keys()].map((n) => this.disconnect(n)));
+    }
+    connectedTools() {
+        return [...this.status.values()].flatMap((s) => (s.state === "connected" ? s.tools : []));
+    }
+    // ToolSource
+    specs() {
+        return this.connectedTools().map(({ name, description, parameters }) => ({ name, description, parameters }));
+    }
+    has(name) {
+        return this.connectedTools().some((t) => t.name === name);
+    }
+    /** Server instructions for the system prompt. */
+    instructions() {
+        return [...this.status.entries()]
+            .flatMap(([name, s]) => (s.state === "connected" && s.instructions ? [`Instructions from the ${name} MCP server:\n${s.instructions}`] : []))
+            .join("\n\n");
+    }
+    async execute(call, { approve, signal }) {
+        const tool = this.connectedTools().find((t) => t.name === call.name);
+        const conn = tool && this.connections.get(tool.server);
+        if (!tool || !conn)
+            return { output: `MCP tool ${call.name} is no longer available.`, isError: true };
+        const args = call.input ?? {};
+        const body = Object.keys(args).length ? JSON.stringify(args, null, 2) : "(no arguments)";
+        if (!(await approve({ tool: call.name, title: `MCP tool ${tool.server} · ${tool.tool}`, body })))
+            return { output: "User denied the tool call.", isError: false };
+        try {
+            const res = await conn.client.callTool({ name: tool.tool, arguments: args }, undefined, {
+                signal,
+                timeout: CALL_TIMEOUT,
+                resetTimeoutOnProgress: true,
+            });
+            return { output: await compactOutput(formatResult(res)), isError: !!res.isError };
+        }
+        catch (e) {
+            return { output: `Error: ${e.message}`, isError: true };
+        }
+    }
+}
+export const mcp = new McpManager();

package/dist/adapters/mcp/results.js

@@ -0,0 +1,21 @@
+function formatPart(p) {
+    switch (p.type) {
+        case "text":
+            return p.text ?? "";
+        case "resource":
+            return p.resource?.text ?? `[resource ${p.resource?.uri}]`;
+        case "resource_link":
+            return `[resource ${p.uri}]`;
+        default:
+            return `[${p.type}${p.mimeType ? ` ${p.mimeType}` : ""} omitted]`;
+    }
+}
+/** An MCP tool result as text for the model: content parts, else structured content as JSON. */
+export function formatResult(res) {
+    const parts = Array.isArray(res.content) ? res.content : [];
+    const text = parts.map(formatPart).join("\n");
+    if (text)
+        return text;
+    const structured = res.structuredContent ?? res.toolResult;
+    return structured === undefined ? "(no output)" : JSON.stringify(structured, null, 2);
+}

package/dist/adapters/mcp/transport.js

@@ -0,0 +1,19 @@
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+const STDERR_TAIL = 2000;
+/** A transport for the config, plus a getter for the tail of a stdio server's stderr (for error messages). */
+export function createTransport(c) {
+    if ("url" in c) {
+        const requestInit = c.headers ? { headers: c.headers } : undefined;
+        const transport = c.type === "sse"
+            ? new SSEClientTransport(new URL(c.url), { requestInit })
+            : new StreamableHTTPClientTransport(new URL(c.url), { requestInit });
+        return { transport, stderr: () => "" };
+    }
+    const env = Object.fromEntries(Object.entries({ ...process.env, ...c.env }).filter((e) => e[1] !== undefined));
+    const transport = new StdioClientTransport({ command: c.command, args: c.args ?? [], env, cwd: process.cwd(), stderr: "pipe" });
+    let stderr = "";
+    transport.stderr?.on("data", (d) => (stderr = (stderr + d).slice(-STDERR_TAIL)));
+    return { transport, stderr: () => stderr };
+}

package/dist/adapters/project.js

@@ -0,0 +1,15 @@
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import { discoverSkills } from "./skills.js";
+const INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md"];
+/** The working directory as the system prompt describes it. */
+export function readProjectContext({ includeInstructions }) {
+    return {
+        cwd: process.cwd(),
+        platform: `${os.platform()} ${os.release()}`,
+        skills: discoverSkills().skills,
+        instructions: includeInstructions
+            ? INSTRUCTION_FILES.filter((file) => existsSync(file)).map((file) => ({ file, text: readFileSync(file, "utf8") }))
+            : [],
+    };
+}

package/dist/adapters/providers/anthropic.js

@@ -0,0 +1,103 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { explicitEffort } from "../../core/provider.js";
+/** Output cap when the model's own limit is unknown, and the most we ask for even when it's higher. */
+const MAX_OUTPUT = 64_000;
+export class AnthropicProvider {
+    client;
+    /** Model limits and capabilities from the Models API, fetched once per model. Null if unavailable. */
+    models = new Map();
+    // Without a key the SDK falls back to $ANTHROPIC_API_KEY or an `ant auth login` profile.
+    constructor(apiKey) {
+        this.client = new Anthropic(apiKey ? { apiKey } : {});
+    }
+    modelInfo(model) {
+        let info = this.models.get(model);
+        if (!info) {
+            // Without the lookup (e.g. a proxy that lacks the endpoint) fall back to the defaults.
+            info = this.client.models.retrieve(model).catch(() => null);
+            this.models.set(model, info);
+        }
+        return info;
+    }
+    async listModels() {
+        const ids = [];
+        for await (const m of this.client.models.list())
+            ids.push(m.id);
+        return ids;
+    }
+    async turn(req) {
+        const info = await this.modelInfo(req.model);
+        const effort = supportedEffort(explicitEffort(req.effort), info);
+        const stream = this.client.messages.stream({
+            model: req.model,
+            ...(effort ? { output_config: { effort } } : {}),
+            // Older models allow fewer output tokens; asking for more is a 400 on every turn.
+            max_tokens: Math.min(info?.max_tokens ?? MAX_OUTPUT, MAX_OUTPUT),
+            system: req.system,
+            cache_control: { type: "ephemeral" },
+            tools: req.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.parameters })),
+            messages: toAnthropic(req.messages),
+        }, { signal: req.signal });
+        stream.on("text", req.onText);
+        const msg = await stream.finalMessage();
+        const text = msg.content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("");
+        const toolCalls = msg.content.flatMap((b) => b.type === "tool_use" ? [{ id: b.id, name: b.name, input: b.input }] : []);
+        return {
+            message: { role: "assistant", text, toolCalls, raw: { provider: "anthropic", content: msg.content } },
+            stop: mapStop(msg.stop_reason),
+            usage: { input: msg.usage.input_tokens, output: msg.usage.output_tokens },
+        };
+    }
+}
+/** The effort to send, or undefined when the model reports it can't take that level (sending it is a 400). */
+function supportedEffort(effort, info) {
+    const support = info?.capabilities?.effort;
+    if (!effort || !support)
+        return effort; // unknown capabilities: send what the user chose
+    return support.supported && support[effort].supported ? effort : undefined;
+}
+function mapStop(r) {
+    switch (r) {
+        case "end_turn":
+        case "stop_sequence":
+            return "end";
+        case "tool_use":
+        case "max_tokens":
+        case "refusal":
+            return r;
+        default:
+            return "other";
+    }
+}
+export function toAnthropic(messages) {
+    const out = [];
+    const push = (role, blocks) => {
+        if (!blocks.length)
+            return; // the API rejects empty turns, e.g. an empty reply
+        const last = out.at(-1);
+        // Merge consecutive same-role turns (e.g. an interrupted tool result followed by new user text).
+        if (last && last.role === role && Array.isArray(last.content))
+            last.content.push(...blocks);
+        else
+            out.push({ role, content: [...blocks] });
+    };
+    for (const m of messages) {
+        if (m.role === "user")
+            push("user", [{ type: "text", text: m.text }]);
+        else if (m.role === "tool")
+            push("user", m.results.map((r) => ({ type: "tool_result", tool_use_id: r.id, content: r.images?.length
+                    ? [{ type: "text", text: r.output }, ...r.images.map((image) => ({ type: "image", source: { type: "base64", media_type: image.mediaType, data: image.data } }))]
+                    : r.output, is_error: r.isError })));
+        else if (m.raw?.provider === "anthropic")
+            push("assistant", m.raw.content);
+        else {
+            const blocks = [];
+            if (m.text)
+                blocks.push({ type: "text", text: m.text });
+            for (const c of m.toolCalls)
+                blocks.push({ type: "tool_use", id: c.id, name: c.name, input: c.input });
+            push("assistant", blocks);
+        }
+    }
+    return out;
+}

package/dist/adapters/providers/catalog.js

@@ -0,0 +1,80 @@
+export const PROVIDER_INFO = [
+    {
+        name: "anthropic",
+        label: "Anthropic",
+        methods: ["key", "ant-cli"],
+        adapter: "anthropic",
+        env: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
+        keyUrl: "https://console.anthropic.com/settings/keys",
+        defaultModel: "claude-opus-5",
+    },
+    {
+        name: "openai",
+        label: "OpenAI",
+        methods: ["chatgpt", "key"],
+        adapter: "openai",
+        env: ["OPENAI_API_KEY"],
+        keyUrl: "https://platform.openai.com/api-keys",
+        defaultModel: "gpt-5",
+        filter: (id) => /^(gpt-|o\d|chatgpt|codex)/.test(id) && !/(audio|realtime|tts|transcribe|image|search|embedding|instruct)/.test(id),
+    },
+    {
+        name: "gemini",
+        label: "Google Gemini",
+        methods: ["key"],
+        adapter: "gemini",
+        env: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+        keyUrl: "https://aistudio.google.com/apikey",
+        defaultModel: "gemini-2.5-pro",
+        filter: (id) => /^gemini/.test(id) && !/(tts|image|embedding)/.test(id),
+    },
+    {
+        name: "openrouter",
+        label: "OpenRouter",
+        methods: ["openrouter-oauth", "key"],
+        adapter: "openai",
+        env: ["OPENROUTER_API_KEY"],
+        baseURL: "https://openrouter.ai/api/v1",
+        keyUrl: "https://openrouter.ai/settings/keys",
+    },
+    {
+        name: "groq",
+        label: "Groq",
+        methods: ["key"],
+        adapter: "openai",
+        env: ["GROQ_API_KEY"],
+        baseURL: "https://api.groq.com/openai/v1",
+        keyUrl: "https://console.groq.com/keys",
+    },
+    {
+        name: "deepseek",
+        label: "DeepSeek",
+        methods: ["key"],
+        adapter: "openai",
+        env: ["DEEPSEEK_API_KEY"],
+        baseURL: "https://api.deepseek.com",
+        keyUrl: "https://platform.deepseek.com/api_keys",
+    },
+    { name: "ollama", label: "Ollama (local)", methods: ["url"], adapter: "openai", env: [], baseURL: "http://localhost:11434/v1", local: true },
+    { name: "lmstudio", label: "LM Studio (local)", methods: ["url"], adapter: "openai", env: [], baseURL: "http://localhost:1234/v1", local: true },
+    {
+        name: "compat",
+        label: "Custom OpenAI-compatible",
+        methods: ["url"],
+        adapter: "openai",
+        env: ["OPENAI_COMPAT_API_KEY"],
+        baseURLEnv: "OPENAI_COMPAT_BASE_URL",
+        keyOptional: true,
+    },
+];
+export const PROVIDERS = PROVIDER_INFO.map((p) => p.name);
+export function providerInfo(name) {
+    const info = PROVIDER_INFO.find((p) => p.name === name);
+    if (!info)
+        throw new Error(`Unknown provider "${name}". Available: ${PROVIDERS.join(", ")}`);
+    return info;
+}
+/** Providers reached through a custom endpoint rather than the vendor's default one. */
+export const usesEndpoint = (info) => !!(info.baseURL || info.baseURLEnv);
+/** The first env var that's set for this provider's key, if any. */
+export const envKeyName = (info) => info.env.find((k) => process.env[k]);