@megacode/cli 0.2.0

package/dist/adapters/providers/chatgpt.js

@@ -0,0 +1,117 @@
+import { randomUUID } from "node:crypto";
+import OpenAI from "openai";
+import { explicitEffort } from "../../core/provider.js";
+import { CHATGPT_BASE_URL, chatGPTHeaders, chatGPTTokens } from "../auth/chatgpt.js";
+import { imageDataUrl, parseToolArguments } from "./shared.js";
+const FALLBACK_MODELS = ["gpt-5", "gpt-5-codex"];
+/** OpenAI models through a ChatGPT subscription, via the Responses API. */
+export class ChatGPTProvider {
+    sessionId = randomUUID();
+    async client(forceRefresh = false) {
+        const t = await chatGPTTokens(forceRefresh);
+        return new OpenAI({
+            apiKey: t.access,
+            baseURL: CHATGPT_BASE_URL,
+            defaultHeaders: { ...chatGPTHeaders(t), session_id: this.sessionId },
+        });
+    }
+    async listModels() {
+        const t = await chatGPTTokens();
+        try {
+            const res = await fetch(`${CHATGPT_BASE_URL}/models?client_version=1.0.0`, {
+                headers: { authorization: `Bearer ${t.access}`, ...chatGPTHeaders(t) },
+            });
+            if (!res.ok)
+                throw new Error(String(res.status));
+            const body = (await res.json());
+            const ids = (body.models ?? []).filter((m) => m.visibility !== "hide").map((m) => m.slug ?? m.id).filter(Boolean);
+            return ids.length ? ids : FALLBACK_MODELS;
+        }
+        catch {
+            return FALLBACK_MODELS;
+        }
+    }
+    async turn(req) {
+        const params = {
+            model: req.model,
+            instructions: req.system,
+            input: toResponses(req.messages),
+            tools: req.tools.map((t) => ({ type: "function", name: t.name, description: t.description, parameters: t.parameters, strict: false })),
+            tool_choice: "auto",
+            parallel_tool_calls: true,
+            reasoning: { effort: explicitEffort(req.effort) ?? "medium", summary: "auto" },
+            store: false,
+            stream: true,
+            include: ["reasoning.encrypted_content"],
+            prompt_cache_key: this.sessionId,
+        };
+        let stream;
+        try {
+            stream = await (await this.client()).responses.create(params, { signal: req.signal });
+        }
+        catch (e) {
+            if (e.status !== 401)
+                throw e;
+            stream = await (await this.client(true)).responses.create(params, { signal: req.signal }); // token revoked early
+        }
+        let text = "";
+        let stop = "end";
+        let usage;
+        const items = [];
+        const toolCalls = [];
+        for await (const ev of stream) {
+            switch (ev.type) {
+                case "response.output_text.delta":
+                    text += ev.delta;
+                    req.onText(ev.delta);
+                    break;
+                case "response.output_item.done":
+                    items.push(ev.item);
+                    if (ev.item.type === "function_call")
+                        toolCalls.push({ id: ev.item.call_id, name: ev.item.name, input: parseToolArguments(ev.item.arguments) });
+                    break;
+                case "response.completed":
+                case "response.incomplete": {
+                    const u = ev.response.usage;
+                    if (u)
+                        usage = { input: u.input_tokens, output: u.output_tokens };
+                    if (ev.type === "response.incomplete")
+                        stop = ev.response.incomplete_details?.reason === "content_filter" ? "refusal" : "max_tokens";
+                    break;
+                }
+                case "response.failed":
+                    throw new Error(ev.response.error?.message ?? "Response failed");
+                case "error":
+                    throw new Error(ev.message);
+            }
+        }
+        if (stop === "end" && toolCalls.length)
+            stop = "tool_use";
+        return { message: { role: "assistant", text, toolCalls, raw: { provider: "openai-responses", content: items } }, stop, usage };
+    }
+}
+export function toResponses(messages) {
+    return messages.flatMap((m) => {
+        if (m.role === "user")
+            return [{ role: "user", content: m.text }];
+        if (m.role === "tool") {
+            const results = m.results.map((r) => ({ type: "function_call_output", call_id: r.id, output: r.output }));
+            // Function outputs are text-only; images follow in a user message.
+            for (const r of m.results) {
+                if (r.images?.length)
+                    results.push({ role: "user", content: [
+                            { type: "input_text", text: r.output },
+                            ...r.images.map((image) => ({ type: "input_image", image_url: imageDataUrl(image), detail: "auto" })),
+                        ] });
+            }
+            return results;
+        }
+        if (m.raw?.provider === "openai-responses")
+            // With store: false the server keeps nothing, so item ids can't be referenced; resend items without them.
+            return m.raw.content.map(({ id: _id, ...item }) => item);
+        return [
+            ...(m.text ? [{ role: "assistant", content: m.text }] : []),
+            ...m.toolCalls.map((c) => ({ type: "function_call", call_id: c.id, name: c.name, arguments: JSON.stringify(c.input) })),
+        ];
+    });
+}

package/dist/adapters/providers/credentials.js

@@ -0,0 +1,55 @@
+import { parseModelSpec } from "../../core/provider.js";
+import { hasAntProfile } from "../auth/anthropic.js";
+import { savedCredentials } from "../auth/store.js";
+import { envKeyName, PROVIDERS, providerInfo } from "./catalog.js";
+/** Resolves credentials in precedence order: environment, ChatGPT sign-in, saved key, local server, external profile. */
+export function credentials(name) {
+    const info = providerInfo(name);
+    const saved = savedCredentials(name) ?? {};
+    const envKey = info.env.map((k) => process.env[k]).find(Boolean);
+    const envURL = info.baseURLEnv && process.env[info.baseURLEnv];
+    const baseURL = envURL || saved.baseURL || info.baseURL;
+    if (envKey)
+        return { apiKey: envKey, baseURL, source: "env" };
+    if (saved.chatgpt)
+        return { source: "chatgpt" };
+    if (saved.apiKey)
+        return { apiKey: saved.apiKey, baseURL, source: "saved" };
+    if (info.local)
+        return { baseURL, source: "local" };
+    // Credentials from `ant auth login`, which the Anthropic SDK picks up on its own.
+    if (info.methods.includes("ant-cli") && hasAntProfile())
+        return { source: "ant-profile" };
+    if (info.keyOptional && baseURL)
+        return { baseURL, source: envURL ? "env" : "saved" };
+    return { baseURL };
+}
+export const isConfigured = (name) => !!credentials(name).source;
+/** The provider half of a "provider:model" spec. */
+export const providerOf = (spec) => parseModelSpec(spec).provider;
+/** True when the spec names a known provider that has no credentials yet. */
+export function needsLogin(spec) {
+    const name = providerOf(spec);
+    return PROVIDERS.includes(name) && !isConfigured(name);
+}
+/** Short human description of how a provider is authenticated. */
+export function authStatus(name) {
+    const info = providerInfo(name);
+    const c = credentials(name);
+    switch (c.source) {
+        case "env":
+            return `via $${envKeyName(info) ?? info.baseURLEnv}`;
+        case "saved":
+            return c.apiKey ? `saved key ••••${c.apiKey.slice(-4)}` : `saved endpoint ${c.baseURL}`;
+        case "chatgpt": {
+            const t = savedCredentials(name)?.chatgpt;
+            return ["ChatGPT", t?.plan, t?.email].filter(Boolean).join(" · ");
+        }
+        case "ant-profile":
+            return "ant CLI profile";
+        case "local":
+            return c.baseURL;
+        default:
+            return "not configured";
+    }
+}

package/dist/adapters/providers/gemini.js

@@ -0,0 +1,123 @@
+import { GoogleGenAI, FinishReason, ThinkingLevel } from "@google/genai";
+import { explicitEffort } from "../../core/provider.js";
+import { fallbackCallId } from "./shared.js";
+export class GeminiProvider {
+    client;
+    filter;
+    // Without a key the SDK reads $GEMINI_API_KEY / $GOOGLE_API_KEY.
+    constructor(apiKey, filter) {
+        this.client = new GoogleGenAI(apiKey ? { apiKey } : {});
+        this.filter = filter;
+    }
+    async listModels() {
+        const ids = [];
+        for await (const m of await this.client.models.list())
+            if (m.name && m.supportedActions?.includes("generateContent"))
+                ids.push(m.name.replace(/^models\//, ""));
+        return ids.filter((id) => !this.filter || this.filter(id)).reverse(); // newest first
+    }
+    async turn(req) {
+        const thinkingConfig = thinkingFor(req.model, explicitEffort(req.effort));
+        const stream = await this.client.models.generateContentStream({
+            model: req.model,
+            contents: toGemini(req.messages),
+            config: {
+                abortSignal: req.signal,
+                ...(thinkingConfig ? { thinkingConfig } : {}),
+                systemInstruction: req.system,
+                tools: [
+                    {
+                        functionDeclarations: req.tools.map((t) => ({
+                            name: t.name,
+                            description: t.description,
+                            parametersJsonSchema: t.parameters,
+                        })),
+                    },
+                ],
+            },
+        });
+        let text = "";
+        let finish;
+        let usage;
+        const parts = [];
+        const toolCalls = [];
+        for await (const chunk of stream) {
+            const cand = chunk.candidates?.[0];
+            if (chunk.usageMetadata)
+                usage = {
+                    input: chunk.usageMetadata.promptTokenCount ?? 0,
+                    output: chunk.usageMetadata.candidatesTokenCount ?? 0,
+                };
+            if (cand?.finishReason)
+                finish = cand.finishReason;
+            for (const part of cand?.content?.parts ?? []) {
+                parts.push(part); // keep everything (incl. thought signatures) for replay
+                if (part.thought)
+                    continue;
+                if (part.text) {
+                    text += part.text;
+                    req.onText(part.text);
+                }
+                if (part.functionCall?.name)
+                    toolCalls.push({
+                        id: part.functionCall.id ?? fallbackCallId(toolCalls.length),
+                        name: part.functionCall.name,
+                        input: part.functionCall.args ?? {},
+                    });
+            }
+        }
+        return {
+            message: { role: "assistant", text, toolCalls, raw: { provider: "gemini", content: parts } },
+            stop: mapStop(finish, toolCalls.length > 0),
+            usage,
+        };
+    }
+}
+/** Gemini 3 takes a thinking level; earlier models take a token budget. */
+function thinkingFor(model, effort) {
+    if (!effort)
+        return undefined;
+    return model.startsWith("gemini-3")
+        ? { thinkingLevel: { low: ThinkingLevel.LOW, medium: ThinkingLevel.MEDIUM, high: ThinkingLevel.HIGH }[effort] }
+        : { thinkingBudget: { low: 1024, medium: 8192, high: 24576 }[effort] };
+}
+function mapStop(r, hasTools) {
+    if (r === FinishReason.MAX_TOKENS)
+        return "max_tokens";
+    if (hasTools)
+        return "tool_use";
+    if (r === FinishReason.STOP)
+        return "end";
+    if (r === FinishReason.SAFETY || r === FinishReason.PROHIBITED_CONTENT || r === FinishReason.BLOCKLIST)
+        return "refusal";
+    return "other";
+}
+export function toGemini(messages) {
+    const out = [];
+    const push = (role, parts) => {
+        if (!parts.length)
+            return; // the API rejects empty turns, e.g. an empty reply
+        const last = out.at(-1);
+        if (last?.role === role)
+            last.parts.push(...parts);
+        else
+            out.push({ role, parts: [...parts] });
+    };
+    for (const m of messages) {
+        if (m.role === "user")
+            push("user", [{ text: m.text }]);
+        else if (m.role === "tool")
+            push("user", m.results.flatMap((r) => [
+                { functionResponse: { id: r.id, name: r.name, response: r.isError ? { error: r.output } : { output: r.output } } },
+                ...(r.images ?? []).map((image) => ({ inlineData: { mimeType: image.mediaType, data: image.data } })),
+            ]));
+        else if (m.raw?.provider === "gemini")
+            push("model", m.raw.content);
+        else
+            push("model", [
+                ...(m.text ? [{ text: m.text }] : []),
+                ...m.toolCalls.map((c) => ({ functionCall: { id: c.id, name: c.name, args: c.input } })),
+            ]);
+    }
+    return out;
+}

package/dist/adapters/providers/openai.js

@@ -0,0 +1,128 @@
+import OpenAI from "openai";
+import { explicitEffort } from "../../core/provider.js";
+import { fallbackCallId, imageDataUrl, parseToolArguments } from "./shared.js";
+// Chat Completions adapter: works for OpenAI and any OpenAI-compatible endpoint
+// (OpenRouter, Ollama, Groq, DeepSeek, LM Studio, vLLM, ...).
+export class OpenAIProvider {
+    client;
+    filter;
+    /** Models that rejected reasoning_effort; it isn't sent to them again this session. */
+    noEffort = new Set();
+    constructor(opts = {}) {
+        this.client = new OpenAI({ apiKey: opts.apiKey, baseURL: opts.baseURL });
+        this.filter = opts.filter;
+    }
+    async listModels() {
+        const models = [];
+        // No retries: an offline local server should just drop out of the picker quickly.
+        for await (const m of this.client.models.list({ maxRetries: 0, timeout: 10_000 }))
+            models.push(m);
+        return models
+            .sort((a, b) => (b.created ?? 0) - (a.created ?? 0) || a.id.localeCompare(b.id))
+            .map((m) => m.id)
+            .filter((id) => !this.filter || this.filter(id));
+    }
+    stream(req, effort) {
+        return this.client.chat.completions.create({
+            model: req.model,
+            ...(effort ? { reasoning_effort: effort } : {}),
+            stream: true,
+            stream_options: { include_usage: true },
+            messages: [{ role: "system", content: req.system }, ...toOpenAI(req.messages)],
+            tools: req.tools.map((t) => ({
+                type: "function",
+                function: { name: t.name, description: t.description, parameters: t.parameters },
+            })),
+        }, { signal: req.signal });
+    }
+    async turn(req) {
+        const effort = this.noEffort.has(req.model) ? undefined : explicitEffort(req.effort);
+        let stream;
+        try {
+            stream = await this.stream(req, effort);
+        }
+        catch (e) {
+            // Models without reasoning (and some compatible servers) reject the parameter instead of ignoring it.
+            if (!effort || !rejectsEffort(e))
+                throw e;
+            this.noEffort.add(req.model);
+            stream = await this.stream(req, undefined);
+        }
+        let text = "";
+        let finish = null;
+        let usage;
+        const calls = [];
+        for await (const chunk of stream) {
+            if (chunk.usage)
+                usage = { input: chunk.usage.prompt_tokens, output: chunk.usage.completion_tokens };
+            const choice = chunk.choices[0];
+            if (!choice)
+                continue;
+            if (choice.delta.content) {
+                text += choice.delta.content;
+                req.onText(choice.delta.content);
+            }
+            for (const tc of choice.delta.tool_calls ?? []) {
+                const c = (calls[tc.index] ??= { id: "", name: "", args: "" });
+                if (tc.id)
+                    c.id = tc.id;
+                if (tc.function?.name)
+                    c.name += tc.function.name;
+                if (tc.function?.arguments)
+                    c.args += tc.function.arguments;
+            }
+            if (choice.finish_reason)
+                finish = choice.finish_reason;
+        }
+        const toolCalls = calls.filter(Boolean).map((c, i) => ({
+            id: c.id || fallbackCallId(i),
+            name: c.name,
+            input: parseToolArguments(c.args),
+        }));
+        return { message: { role: "assistant", text, toolCalls }, stop: mapStop(finish, toolCalls.length > 0), usage };
+    }
+}
+const rejectsEffort = (e) => e instanceof OpenAI.BadRequestError && (e.param === "reasoning_effort" || /reasoning_effort/.test(e.message));
+function mapStop(r, hasTools) {
+    if (r === "length")
+        return "max_tokens";
+    if (r === "content_filter")
+        return "refusal";
+    if (hasTools || r === "tool_calls")
+        return "tool_use";
+    return r === "stop" ? "end" : "other";
+}
+export function toOpenAI(messages) {
+    return messages.flatMap((m) => {
+        if (m.role === "user")
+            return [{ role: "user", content: m.text }];
+        if (m.role === "tool") {
+            const results = m.results.map((r) => ({ role: "tool", tool_call_id: r.id, content: r.output }));
+            // Chat Completions only accepts images in user messages, after all tool replies.
+            for (const r of m.results) {
+                if (r.images?.length)
+                    results.push({ role: "user", content: [
+                            { type: "text", text: r.output },
+                            ...r.images.map((image) => ({ type: "image_url", image_url: { url: imageDataUrl(image) } })),
+                        ] });
+            }
+            return results;
+        }
+        // An assistant message needs content or tool calls; leave out empty replies.
+        if (!m.text && !m.toolCalls.length)
+            return [];
+        return [
+            {
+                role: "assistant",
+                content: m.text || null,
+                ...(m.toolCalls.length && {
+                    tool_calls: m.toolCalls.map((c) => ({
+                        id: c.id,
+                        type: "function",
+                        function: { name: c.name, arguments: JSON.stringify(c.input) },
+                    })),
+                }),
+            },
+        ];
+    });
+}

package/dist/adapters/providers/registry.js

@@ -0,0 +1,68 @@
+import { parseModelSpec } from "../../core/provider.js";
+import { loadSettings } from "../settings.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { PROVIDER_INFO, PROVIDERS, providerInfo, usesEndpoint } from "./catalog.js";
+import { ChatGPTProvider } from "./chatgpt.js";
+import { credentials, isConfigured, needsLogin, providerOf } from "./credentials.js";
+import { GeminiProvider } from "./gemini.js";
+import { OpenAIProvider } from "./openai.js";
+export function createProvider(name, creds = credentials(name)) {
+    const info = providerInfo(name);
+    if (creds.source === "chatgpt")
+        return new ChatGPTProvider();
+    switch (info.adapter) {
+        case "anthropic":
+            return new AnthropicProvider(creds.apiKey);
+        case "gemini":
+            return new GeminiProvider(creds.apiKey, info.filter);
+        case "openai": {
+            // Without an endpoint the SDK uses api.openai.com and reads $OPENAI_API_KEY itself.
+            if (!usesEndpoint(info))
+                return new OpenAIProvider({ apiKey: creds.apiKey, filter: info.filter });
+            if (!creds.baseURL)
+                throw new Error(`No endpoint configured for ${info.label}. Run /login.`);
+            // Local servers don't need a key, but the SDK requires a non-empty one.
+            return new OpenAIProvider({ baseURL: creds.baseURL, apiKey: creds.apiKey ?? "none", filter: info.filter });
+        }
+    }
+}
+const providers = new Map();
+const modelLists = new Map();
+/** Drop cached clients and model lists after credentials change. */
+export function resetProvider(name) {
+    providers.delete(name);
+    modelLists.delete(name);
+}
+function getProvider(name) {
+    let provider = providers.get(name);
+    if (!provider)
+        providers.set(name, (provider = createProvider(name)));
+    return provider;
+}
+/** Live model list for a provider, cached for the session. */
+export function listModels(name) {
+    let list = modelLists.get(name);
+    if (!list) {
+        list = getProvider(name).listModels();
+        list.catch(() => modelLists.delete(name)); // retry next time
+        modelLists.set(name, list);
+    }
+    return list;
+}
+/** Resolves "provider:model" (or a bare provider name, meaning its default model). */
+export const resolveModel = (spec) => {
+    const { provider, model = providerInfo(provider).defaultModel } = parseModelSpec(spec);
+    if (!model)
+        throw new Error(`Specify a model, e.g. ${provider}:<model>, or pick one with /model`);
+    return { provider: getProvider(provider), model };
+};
+/** $MEGACODE_MODEL, else the last model used, else the first configured provider's default. */
+export function defaultModel() {
+    if (process.env.MEGACODE_MODEL)
+        return process.env.MEGACODE_MODEL;
+    const last = loadSettings().model;
+    if (last && PROVIDERS.includes(providerOf(last)) && !needsLogin(last))
+        return last;
+    const p = PROVIDER_INFO.find((p) => p.defaultModel && isConfigured(p.name)) ?? PROVIDER_INFO[0];
+    return `${p.name}:${p.defaultModel}`;
+}

package/dist/adapters/providers/shared.js

@@ -0,0 +1,12 @@
+/** Streamed tool arguments → object. Invalid JSON is kept so the tool layer can report it to the model. */
+export function parseToolArguments(json) {
+    try {
+        return json ? JSON.parse(json) : {};
+    }
+    catch {
+        return { _invalid_json: json };
+    }
+}
+/** Some providers and compatible servers omit tool call ids; every call needs one to pair with its result. */
+export const fallbackCallId = (index) => `call_${Date.now()}_${index}`;
+export const imageDataUrl = (image) => `data:${image.mediaType};base64,${image.data}`;

package/dist/adapters/providers/usage.js

@@ -0,0 +1,95 @@
+import { chatGPTUsage } from "../auth/chatgpt.js";
+import { providerInfo } from "./catalog.js";
+import { credentials } from "./credentials.js";
+const number = (v) => typeof v === "number" && Number.isFinite(v);
+const object = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+/** Only display values actually returned by the provider; missing values aren't zero. */
+export function formatChatGPTUsage(value) {
+    const data = object(value);
+    const lines = [];
+    if (typeof data.plan_type === "string")
+        lines.push(`Plan: ${data.plan_type}`);
+    for (const [key, label] of [["rate_limit", "Usage"], ["code_review_rate_limit", "Code review"]]) {
+        const limit = object(data[key]);
+        if (typeof limit.allowed === "boolean")
+            lines.push(`${label}: ${limit.allowed ? "available" : "limit reached"}`);
+        for (const [key, fallback] of [["primary_window", "Primary window"], ["secondary_window", "Secondary window"]]) {
+            const window = object(limit[key]);
+            if (number(window.used_percent))
+                lines.push(formatWindow(label, fallback, window));
+        }
+    }
+    const credits = object(data.credits);
+    if (credits.unlimited === true)
+        lines.push("Credits: unlimited");
+    else if (typeof credits.balance === "string" || number(credits.balance))
+        lines.push(`Credits remaining: ${credits.balance}`);
+    return lines;
+}
+function formatWindow(label, fallback, window) {
+    const duration = window.limit_window_seconds;
+    const name = number(duration) ? `${duration / 3600}-hour window` : fallback;
+    const used = window.used_percent;
+    const filled = Math.round(Math.min(100, Math.max(0, used)) / 100 * 24);
+    const bar = "█".repeat(filled) + "░".repeat(24 - filled);
+    let line = `${label} (${name})\n  ${bar}  ${used}% used · ${Math.max(0, 100 - used)}% remaining`;
+    if (number(window.reset_at)) {
+        const date = new Date(window.reset_at * 1000);
+        if (!Number.isNaN(date.getTime()))
+            line += `\n  Resets ${date.toLocaleString()}`;
+    }
+    else if (number(window.reset_after_seconds))
+        line += `\n  Resets in ${Math.ceil(window.reset_after_seconds / 60)} min`;
+    return line;
+}
+async function get(url, apiKey) {
+    const res = await fetch(url, {
+        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok)
+        throw new Error(`Usage request failed (HTTP ${res.status}).${[401, 403].includes(res.status) ? " Run /login to update credentials." : ""}`);
+    return res.json();
+}
+const endpoint = (creds, path) => `${creds.baseURL.replace(/\/$/, "")}${path}`;
+const OPENROUTER_FIELDS = [
+    ["usage", "Used (total)"], ["usage_daily", "Used (today)"], ["usage_weekly", "Used (this week)"],
+    ["usage_monthly", "Used (this month)"], ["limit", "Key spending limit"], ["limit_remaining", "Remaining"],
+];
+/** Per-provider usage lookups. Returning undefined means this credential type has no usage API. */
+const FETCHERS = {
+    async openai(creds) {
+        return creds.source === "chatgpt" ? formatChatGPTUsage(await chatGPTUsage()) : undefined;
+    },
+    async openrouter(creds) {
+        const data = object(object(await get(endpoint(creds, "/key"), creds.apiKey)).data);
+        const lines = OPENROUTER_FIELDS.flatMap(([key, label]) => (number(data[key]) ? [`${label}: $${data[key]}`] : []));
+        if (data.limit === null)
+            lines.push("Key spending limit: unlimited");
+        if (typeof data.limit_reset === "string")
+            lines.push(`Limit reset: ${data.limit_reset}`);
+        return lines;
+    },
+    async deepseek(creds) {
+        const data = object(await get(endpoint(creds, "/user/balance"), creds.apiKey));
+        const lines = [];
+        for (const entry of Array.isArray(data.balance_infos) ? data.balance_infos : []) {
+            const balance = object(entry);
+            if (typeof balance.currency === "string" && (typeof balance.total_balance === "string" || number(balance.total_balance)))
+                lines.push(`Balance remaining: ${balance.total_balance} ${balance.currency}`);
+        }
+        lines.push("Usage totals and limits are not exposed by this provider's balance API.");
+        return lines;
+    },
+};
+/** Fresh account data, using the same credential precedence as model requests. */
+export async function providerUsage(name, creds = credentials(name)) {
+    const info = providerInfo(name);
+    const heading = `${info.label} — account usage and limits`;
+    if (!creds.source)
+        return `${heading}\nNot configured. Run /login.`;
+    const lines = await FETCHERS[name]?.(creds);
+    if (!lines)
+        return `${heading}\n${info.local ? "Local provider: no account quota API." : "Account usage and limits are not available through this provider's configured authentication/API. Check the provider dashboard."}`;
+    return `${heading}\n${lines.length ? lines.join("\n") : "The provider returned no usage or limit data."}`;
+}

package/dist/adapters/settings.js

@@ -0,0 +1,15 @@
+import { DEFAULT_SETTINGS } from "../core/settings.js";
+import { configDir, readJson, writeJson } from "./storage.js";
+const FILE = "settings.json";
+// Only values the user changed are written, so later changes to defaults still apply.
+let cache;
+function savedSettings() {
+    if (cache?.dir !== configDir())
+        cache = { dir: configDir(), saved: readJson(FILE, {}) };
+    return cache.saved;
+}
+export const loadSettings = () => ({ ...DEFAULT_SETTINGS, ...savedSettings() });
+export function updateSettings(patch) {
+    cache = { dir: configDir(), saved: { ...savedSettings(), ...patch } };
+    writeJson(FILE, cache.saved);
+}