@nextxai/cli 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.2.0
+
+- `--model`: answer with your own model on your machine — Claude, Gemini, GPT, Grok or Ollama — using your workspace tools over MCP. Writes still only create a proposal you confirm. `model add|list|remove|default`, and `/model` switches inside the chat.
+- AI tool access (`tools`, `--model`) now works in workspaces that allow verified AI apps only (the default): the CLI identifies itself with a client metadata document on the developer portal instead of registering a new client.
+- `login --ci`: GitHub Actions / GitLab CI sign in with their OIDC token, no secret. Admins allow a repository with `ci trust add`.
+
 ## 0.1.1
 
 - x64 builds (Intel Mac, Linux, Windows) now target every x64 CPU, including older Intel Macs without AVX2.

package/dist/ai/client.js

@@ -7,17 +7,21 @@ import { get, post, put, patch, del, requestRaw, errorFor, networkError } from "
 import { CliError, Exit } from "../core/errors.js";
 import { tr } from "../core/i18n.js";
 import { brand } from "../core/brand.js";
+import * as nf from "./nextfarm.js";
+/** NextFarm talks to its own assistant API (see nextfarm.ts); the other brands share this file's contract. */
+const farm = () => brand().platform === "nextfarm";
 const BASE = "/operator/widget/support";
-export const openConversation = (forceNew) => post(`${BASE}/init`, { forceNew });
-export const listConversations = (limit = 30) => get(`${BASE}/conversations`, { query: { limit } });
-export const renameConversation = (id, title) => patch(`${BASE}/conversations/${id}/title`, { title });
-export const pinConversation = (id, pinned) => put(`${BASE}/conversations/${id}/pin`, { pinned });
-export const deleteConversation = (id) => del(`${BASE}/conversations/${id}`);
-export const history = (sessionId) => get(`${BASE}/history`, { query: { sessionId } });
-export const feedback = (messageId, helpful) => post(`${BASE}/messages/${messageId}/feedback`, { helpful });
-export const escalate = (sessionId, topic) => post(`${BASE}/escalate`, { sessionId, topic });
-export const usage = () => get(`${BASE}/usage`);
-export const confirmAction = (sessionId, a) => post(`${BASE}/${sessionId}/confirm-action`, { kind: a.kind, payloadJson: a.payloadJson, nonce: a.nonce });
+export const openConversation = (forceNew) => farm() ? nf.openConversation(forceNew) : post(`${BASE}/init`, { forceNew });
+export const listConversations = (limit = 30) => farm() ? nf.listConversations(limit) : get(`${BASE}/conversations`, { query: { limit } });
+export const renameConversation = (id, title) => farm() ? nf.renameConversation(id, title) : patch(`${BASE}/conversations/${id}/title`, { title });
+export const pinConversation = (id, pinned) => farm() ? nf.pinConversation(id, pinned) : put(`${BASE}/conversations/${id}/pin`, { pinned });
+export const deleteConversation = (id) => farm() ? nf.deleteConversation(id) : del(`${BASE}/conversations/${id}`);
+export const history = (sessionId) => farm() ? nf.history(sessionId) : get(`${BASE}/history`, { query: { sessionId } });
+export const feedback = (messageId, helpful) => farm() ? nf.feedback(messageId, helpful) : post(`${BASE}/messages/${messageId}/feedback`, { helpful });
+export const escalate = (sessionId, topic) => farm() ? nf.escalate(sessionId, topic) : post(`${BASE}/escalate`, { sessionId, topic });
+export const usage = () => farm() ? nf.usage() : get(`${BASE}/usage`);
+export const confirmAction = (sessionId, a) => farm() ? nf.confirmAction(sessionId, a) :
+    post(`${BASE}/${sessionId}/confirm-action`, { kind: a.kind, payloadJson: a.payloadJson, nonce: a.nonce });
 const TABLE = new Set([".xlsx", ".csv"]);
 const IMAGE = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
 const TEXT = new Set([".txt", ".md", ".json", ".log", ".yml", ".yaml", ".tsv", ".xml", ".html", ".sql"]);
@@ -25,6 +29,8 @@ const MAX_BYTES = 10 * 1024 * 1024;
 const MAX_TEXT = 20_000;
 export function attachmentKind(path) {
     const ext = extname(path).toLowerCase();
+    if (farm() && nf.isDocument(path))
+        return "table";
     if (TABLE.has(ext))
         return "table";
     if (ext in IMAGE)
@@ -61,6 +67,8 @@ export async function attach(path, sessionId) {
         const cut = raw.length > MAX_TEXT;
         return { path, name, kind, text: cut ? raw.slice(0, MAX_TEXT) : raw, summary: tr(`${raw.length.toLocaleString("vi-VN")} ký tự${cut ? ", đã cắt" : ""}`, `${raw.length} chars${cut ? ", truncated" : ""}`) };
     }
+    if (farm())
+        return nf.attachBinary(path, kind);
     if (size > MAX_BYTES)
         throw new CliError(tr("Tệp quá lớn (tối đa 10 MB).", "File too large (max 10 MB)."), Exit.usage);
     const body = readFileSync(path);
@@ -90,6 +98,8 @@ export function composeText(question, attachments, projectNotes) {
  * so the server replays the stored answer instead of answering (and charging) twice.
  */
 export async function ask(input) {
+    if (farm())
+        return nf.ask(input);
     const key = randomUUID();
     const body = {
         sessionId: input.sessionId,
@@ -187,6 +197,8 @@ const FINANCE = /payment|invoice|einvoice|finance|refund|payout|wallet|billing|t
 const LARGE = /delete|remove|merge|bulk|batch|mass|permission|role|group|xoa|gop|hang.?loat|campaign|broadcast/i;
 /** Large = deletes, merges, permission changes, > 20 records or recipients. Finance never runs from the terminal. */
 export function riskOf(a) {
+    if (a.risk)
+        return a.risk;
     if (FINANCE.test(a.kind))
         return "finance";
     if (LARGE.test(a.kind))

package/dist/ai/local.js

@@ -0,0 +1,286 @@
+// --model: the agent loop runs on this machine with the user's own model; tools come from the workspace's
+// MCP server. Writes follow MCP rules (a proposal with a confirmation link), so the loop never writes by itself.
+// Emits the same StreamChunk events as the platform assistant, so the REPL and -p render both the same way.
+import Anthropic from "@anthropic-ai/sdk";
+import { fetch } from "undici";
+import { CliError, Exit } from "../core/errors.js";
+import { tr, currentLang } from "../core/i18n.js";
+import { brand } from "../core/brand.js";
+import { getProfile } from "../core/config.js";
+import { context } from "../core/context.js";
+import { networkError, serverMessage, userAgent } from "../core/http.js";
+import { McpClient, resultValue } from "../mcp/client.js";
+const MAX_STEPS = 25;
+/** Tool output beyond this is cut with a note; one report can otherwise fill the model's context. */
+const MAX_RESULT_CHARS = 60_000;
+/** Models that accept the server-side refusal fallback ("default" routing). */
+const FALLBACK_MODELS = /^claude-(fable-5-1|opus-5-5|opus-5|sonnet-5-5)$/;
+/** Provider tool names allow [A-Za-z0-9_-] only; MCP names may carry dots. */
+const wireName = (n) => n.replace(/[^A-Za-z0-9_-]/g, "__").slice(0, 64);
+function systemPrompt(readOnly) {
+    const b = brand();
+    const p = getProfile(context().profile);
+    const lang = currentLang() === "en" ? "English" : "Vietnamese";
+    return [
+        `You are a terminal assistant for ${b.name}, working on the user's live workspace data through the tools provided.`,
+        `Workspace: ${p?.workspaceName ?? p?.workspaceCode ?? "-"} (${context().env}). Today: ${new Date().toISOString().slice(0, 10)}.`,
+        "Answer from tool results only; if no tool can answer, say so instead of guessing numbers.",
+        readOnly
+            ? "This session is read-only: do not try to change data."
+            : "Tools that change data only create a proposal and return a confirmation link. Nothing is saved until the user opens the link and confirms. Show the link and say clearly that the change is not made yet.",
+        `Reply in ${lang} unless the user writes in another language. Output is shown in a terminal: short paragraphs, plain Markdown lists and tables, no HTML.`,
+    ].join("\n");
+}
+function resultText(r) {
+    const v = resultValue(r);
+    const s = typeof v === "string" ? v : JSON.stringify(v);
+    return s.length > MAX_RESULT_CHARS ? `${s.slice(0, MAX_RESULT_CHARS)}\n[… ${s.length - MAX_RESULT_CHARS} more characters cut]` : s;
+}
+export class LocalChat {
+    model;
+    readOnly;
+    mcp;
+    tools;
+    claudeHistory = [];
+    chatHistory = [];
+    anthropic;
+    constructor(model, interactive, readOnly = false) {
+        this.model = model;
+        this.readOnly = readOnly;
+        this.mcp = new McpClient(interactive);
+    }
+    async loadTools() {
+        if (this.tools)
+            return this.tools;
+        const all = await this.mcp.listTools();
+        const usable = this.readOnly ? all.filter((t) => t.annotations?.readOnlyHint) : all;
+        const seen = new Set();
+        this.tools = usable
+            .map((tool) => ({ wire: wireName(tool.name), tool }))
+            .filter((t) => !seen.has(t.wire) && seen.add(t.wire));
+        return this.tools;
+    }
+    async runTool(wire, args, onChunk, outcome) {
+        const t = this.tools?.find((x) => x.wire === wire);
+        if (!t)
+            return { text: `Unknown tool ${wire}`, isError: true };
+        const label = t.tool.annotations?.title ?? t.tool.title ?? t.tool.name;
+        const started = Date.now();
+        const activity = { kind: "tool", label, toolName: t.tool.name, elapsedMs: null };
+        if (!args || typeof args !== "object" || Array.isArray(args))
+            return { text: "Tool input must be a JSON object.", isError: true };
+        try {
+            const r = await this.mcp.callTool(t.tool.name, args);
+            activity.elapsedMs = Date.now() - started;
+            outcome.activities.push(activity);
+            onChunk({ type: "activity", activity });
+            return { text: resultText(r), isError: !!r.isError };
+        }
+        catch (e) {
+            // An expired MCP grant ends the turn; other failures go back to the model so it can adjust.
+            if (e instanceof CliError && e.exitCode === Exit.auth)
+                throw e;
+            activity.elapsedMs = Date.now() - started;
+            outcome.activities.push(activity);
+            onChunk({ type: "activity", activity });
+            return { text: e.message, isError: true };
+        }
+    }
+    async ask(input) {
+        const tools = await this.loadTools();
+        const outcome = { text: "", notices: [], activities: [], ended: "done" };
+        if (this.model.api === "anthropic")
+            await this.askClaude(input, tools, outcome);
+        else
+            await this.askChat(input, tools, outcome);
+        outcome.done = { type: outcome.ended, text: outcome.text };
+        input.onChunk(outcome.done);
+        return outcome;
+    }
+    // ── Anthropic Messages ───────────────────────────────────────────────────────────────────────────
+    async askClaude(input, tools, outcome) {
+        this.anthropic ??= new Anthropic({ apiKey: this.model.apiKey, baseURL: this.model.baseUrl, defaultHeaders: { "User-Agent": userAgent() } });
+        const defs = tools.map((t) => ({
+            name: t.wire,
+            description: (t.tool.description ?? t.tool.title ?? t.tool.name).slice(0, 4000),
+            input_schema: (t.tool.inputSchema ?? { type: "object", properties: {} }),
+        }));
+        const fallback = FALLBACK_MODELS.test(this.model.model);
+        this.claudeHistory.push({ role: "user", content: input.text });
+        for (let step = 0; step < MAX_STEPS; step++) {
+            let msg;
+            try {
+                const stream = this.anthropic.beta.messages.stream({
+                    model: this.model.model,
+                    max_tokens: 32_000,
+                    system: [{ type: "text", text: systemPrompt(this.readOnly), cache_control: { type: "ephemeral" } }],
+                    tools: defs,
+                    messages: this.claudeHistory,
+                    ...(fallback ? { betas: ["server-side-fallback-2026-07-01"], fallbacks: "default" } : {}),
+                }, { signal: input.signal });
+                stream.on("text", (d) => {
+                    outcome.text += d;
+                    input.onChunk({ type: "token", text: d });
+                });
+                msg = await stream.finalMessage();
+            }
+            catch (e) {
+                throw anthropicError(e, input.signal);
+            }
+            // Append the whole content (thinking and fallback blocks included) so the next turn replays it unchanged.
+            this.claudeHistory.push({ role: "assistant", content: msg.content });
+            if (msg.stop_reason === "refusal") {
+                outcome.notices.push({ code: "model_refusal", message: tr("Model từ chối trả lời câu này.", "The model declined to answer this.") });
+                outcome.ended = "error";
+                return;
+            }
+            const uses = msg.content.filter((b) => b.type === "tool_use");
+            if (msg.stop_reason === "max_tokens") {
+                outcome.notices.push({ code: "model_max_tokens", message: tr("Câu trả lời bị cắt vì quá dài.", "The answer was cut off for length.") });
+                // A tool call cut mid-input must not run; close it so the history stays valid.
+                if (uses.length)
+                    this.claudeHistory.push({ role: "user", content: uses.map((u) => ({ type: "tool_result", tool_use_id: u.id, content: "Not run: the call was cut off.", is_error: true })) });
+                return;
+            }
+            if (msg.stop_reason === "pause_turn")
+                continue;
+            if (msg.stop_reason !== "tool_use" || !uses.length)
+                return;
+            if (outcome.text && !outcome.text.endsWith("\n")) {
+                outcome.text += "\n";
+                input.onChunk({ type: "token", text: "\n" });
+            }
+            const results = await Promise.all(uses.map((u) => this.runTool(u.name, u.input, input.onChunk, outcome)));
+            this.claudeHistory.push({
+                role: "user",
+                content: uses.map((u, i) => ({ type: "tool_result", tool_use_id: u.id, content: results[i].text, ...(results[i].isError ? { is_error: true } : {}) })),
+            });
+        }
+        outcome.notices.push({ code: "model_steps", message: tr(`Dừng sau ${MAX_STEPS} bước gọi công cụ.`, `Stopped after ${MAX_STEPS} tool steps.`) });
+    }
+    // ── chat-completions (GPT, Gemini, Grok, Ollama) ─────────────────────────────────────────────────
+    async askChat(input, tools, outcome) {
+        const defs = tools.map((t) => ({
+            type: "function",
+            function: { name: t.wire, description: (t.tool.description ?? t.tool.title ?? t.tool.name).slice(0, 1000), parameters: t.tool.inputSchema ?? { type: "object", properties: {} } },
+        }));
+        if (!this.chatHistory.length)
+            this.chatHistory.push({ role: "system", content: systemPrompt(this.readOnly) });
+        this.chatHistory.push({ role: "user", content: input.text });
+        for (let step = 0; step < MAX_STEPS; step++) {
+            const turn = await this.chatTurn(defs, input, outcome);
+            this.chatHistory.push({ role: "assistant", content: turn.content || null, ...(turn.calls.length ? { tool_calls: turn.calls } : {}) });
+            if (turn.finish === "length") {
+                outcome.notices.push({ code: "model_max_tokens", message: tr("Câu trả lời bị cắt vì quá dài.", "The answer was cut off for length.") });
+                for (const call of turn.calls)
+                    this.chatHistory.push({ role: "tool", tool_call_id: call.id, content: "Not run: the call was cut off." });
+                return;
+            }
+            if (!turn.calls.length)
+                return;
+            if (outcome.text && !outcome.text.endsWith("\n")) {
+                outcome.text += "\n";
+                input.onChunk({ type: "token", text: "\n" });
+            }
+            const results = await Promise.all(turn.calls.map((call) => {
+                let args;
+                try {
+                    args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+                }
+                catch {
+                    return Promise.resolve({ text: "Invalid JSON arguments; send a valid JSON object.", isError: true });
+                }
+                return this.runTool(call.function.name, args, input.onChunk, outcome);
+            }));
+            turn.calls.forEach((call, i) => this.chatHistory.push({ role: "tool", tool_call_id: call.id, content: results[i].isError ? `ERROR: ${results[i].text}` : results[i].text }));
+        }
+        outcome.notices.push({ code: "model_steps", message: tr(`Dừng sau ${MAX_STEPS} bước gọi công cụ.`, `Stopped after ${MAX_STEPS} tool steps.`) });
+    }
+    async chatTurn(defs, input, outcome) {
+        const url = `${this.model.baseUrl}/chat/completions`;
+        let res;
+        try {
+            res = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Accept: "text/event-stream", "User-Agent": userAgent(), ...(this.model.apiKey ? { Authorization: `Bearer ${this.model.apiKey}` } : {}) },
+                body: JSON.stringify({ model: this.model.model, messages: this.chatHistory, ...(defs.length ? { tools: defs } : {}), stream: true }),
+                signal: input.signal,
+            });
+        }
+        catch (e) {
+            throw networkError(e, url);
+        }
+        if (!res.ok) {
+            const body = await res.json().catch(() => undefined);
+            throw providerError(this.model, res.status, serverMessage(body?.error ?? body).message);
+        }
+        let content = "";
+        let finish;
+        const calls = [];
+        const decoder = new TextDecoder();
+        let buf = "";
+        for await (const part of res.body ?? []) {
+            buf += decoder.decode(part, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line.startsWith("data:"))
+                    continue;
+                const data = line.slice(5).trim();
+                if (data === "[DONE]")
+                    continue;
+                let ev;
+                try {
+                    ev = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                const ch = ev.choices?.[0];
+                if (!ch)
+                    continue;
+                if (ch.finish_reason)
+                    finish = ch.finish_reason;
+                const d = ch.delta;
+                if (d?.content) {
+                    content += d.content;
+                    outcome.text += d.content;
+                    input.onChunk({ type: "token", text: d.content });
+                }
+                for (const tc of d?.tool_calls ?? []) {
+                    const i = tc.index ?? calls.length;
+                    calls[i] ??= { id: tc.id ?? `call_${i}`, type: "function", function: { name: "", arguments: "" } };
+                    if (tc.id)
+                        calls[i].id = tc.id;
+                    if (tc.function?.name)
+                        calls[i].function.name += tc.function.name;
+                    if (tc.function?.arguments)
+                        calls[i].function.arguments += tc.function.arguments;
+                }
+            }
+        }
+        return { content, calls: calls.filter(Boolean), finish };
+    }
+}
+function providerError(m, status, message) {
+    const who = m.label;
+    if (status === 401 || status === 403)
+        return new CliError(tr(`${who}: khoá model bị từ chối.`, `${who}: the model key was rejected.`) + (message ? ` (${message})` : ""), Exit.auth, `${brand().bin} model add ${m.provider} --key-from-stdin`);
+    if (status === 404)
+        return new CliError(tr(`${who}: không có model này.`, `${who}: no such model.`) + (message ? ` (${message})` : ""), Exit.notFound);
+    if (status === 429)
+        return new CliError(tr(`${who}: nhà model đang giới hạn tốc độ hoặc hết hạn mức.`, `${who}: the provider is rate limiting or out of quota.`) + (message ? ` (${message})` : ""), Exit.quota);
+    return new CliError(`${who}: HTTP ${status}${message ? ` ${message}` : ""}`, Exit.general);
+}
+function anthropicError(e, signal) {
+    if (signal?.aborted || e instanceof Anthropic.APIUserAbortError)
+        return new CliError(tr("Đã dừng.", "Stopped."), Exit.interrupted);
+    if (e instanceof Anthropic.APIConnectionError)
+        return new CliError(tr("Không kết nối được tới nhà model.", "Could not reach the model provider."), Exit.network);
+    if (e instanceof Anthropic.APIError) {
+        const m = { provider: "claude", label: "claude" };
+        return providerError(m, e.status ?? 0, e.message);
+    }
+    return e;
+}

package/dist/ai/models.js

@@ -0,0 +1,87 @@
+// The user's own model (--model): which providers exist, where their keys live, how a spec like
+// "claude", "gpt/<name>" or "ollama/qwen3:32b" resolves. Keys stay in the keychain and never go to the platform.
+import { CliError, Exit } from "../core/errors.js";
+import { tr } from "../core/i18n.js";
+import { brand } from "../core/brand.js";
+import { loadConfig, saveConfig } from "../core/config.js";
+import { readSecret, writeSecret, deleteSecret } from "../auth/credentials.js";
+// A→Z, no provider is favoured.
+export const PROVIDERS = {
+    claude: { label: "Claude (Anthropic)", api: "anthropic", baseUrl: "https://api.anthropic.com", keyEnv: "ANTHROPIC_API_KEY", defaultModel: "claude-opus-5-5", needsKey: true },
+    gemini: { label: "Gemini (Google)", api: "chat", baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai", keyEnv: "GEMINI_API_KEY", needsKey: true },
+    gpt: { label: "GPT (OpenAI)", api: "chat", baseUrl: "https://api.openai.com/v1", keyEnv: "OPENAI_API_KEY", needsKey: true },
+    grok: { label: "Grok (xAI)", api: "chat", baseUrl: "https://api.x.ai/v1", keyEnv: "XAI_API_KEY", needsKey: true },
+    ollama: { label: "Ollama (máy bạn / your machine)", api: "chat", baseUrl: "http://localhost:11434", needsKey: false },
+};
+const stored = () => loadConfig();
+function save(patch) {
+    const c = loadConfig();
+    patch(c);
+    saveConfig(c);
+}
+export const isProvider = (p) => p in PROVIDERS;
+export function listModels() {
+    const s = stored();
+    return Object.entries(s.models ?? {}).map(([name, entry]) => ({
+        name,
+        entry,
+        hasKey: !PROVIDERS[entry.provider].needsKey || !!keyFor(entry.provider),
+        isDefault: s.defaultModel === name,
+    }));
+}
+export function addModel(provider, opts) {
+    if (PROVIDERS[provider].needsKey && opts.key)
+        writeSecret(`model:${provider}`, opts.key.trim());
+    save((s) => {
+        s.models = { ...s.models, [provider]: { provider, ...(opts.model ? { model: opts.model } : {}), ...(opts.url ? { url: opts.url.replace(/\/+$/, "") } : {}) } };
+    });
+}
+export function removeModel(name) {
+    const s = stored();
+    const entry = s.models?.[name];
+    if (!entry)
+        return false;
+    deleteSecret(`model:${entry.provider}`);
+    save((x) => {
+        delete x.models?.[name];
+        if (x.defaultModel === name)
+            delete x.defaultModel;
+    });
+    return true;
+}
+export function setDefaultModel(name) {
+    save((s) => {
+        if (name)
+            s.defaultModel = name;
+        else
+            delete s.defaultModel;
+    });
+}
+export const defaultModel = () => stored().defaultModel;
+function keyFor(p) {
+    const env = PROVIDERS[p].keyEnv;
+    return (env && process.env[env]) || readSecret(`model:${p}`);
+}
+/** The CLI's own command name (or "default") means the platform assistant: returns undefined. */
+export function resolveModel(spec) {
+    const s = spec.trim();
+    if (!s || s === brand().bin || s === "default")
+        return undefined;
+    const slash = s.indexOf("/");
+    const head = slash < 0 ? s : s.slice(0, slash);
+    const name = slash < 0 ? undefined : s.slice(slash + 1);
+    if (!isProvider(head))
+        throw new CliError(tr(`Không biết nhà model "${head}".`, `Unknown model provider "${head}".`), Exit.usage, tr(`Có: ${Object.keys(PROVIDERS).join(", ")} (vd --model ollama/qwen3:32b)`, `Available: ${Object.keys(PROVIDERS).join(", ")} (e.g. --model ollama/qwen3:32b)`));
+    const info = PROVIDERS[head];
+    const entry = stored().models?.[head];
+    const model = name || entry?.model || info.defaultModel;
+    if (!model)
+        throw new CliError(tr(`Cần tên model cho ${head}.`, `Name the ${head} model.`), Exit.usage, `${brand().bin} --model ${head}/<model>  ·  ${brand().bin} model add ${head} --name <model>`);
+    const apiKey = keyFor(head);
+    if (info.needsKey && !apiKey)
+        throw new CliError(tr(`Chưa có khoá ${info.label}.`, `No ${info.label} key yet.`), Exit.auth, `${brand().bin} model add ${head} --key-from-stdin${info.keyEnv ? tr(` (hoặc đặt ${info.keyEnv})`, ` (or set ${info.keyEnv})`) : ""}`);
+    let baseUrl = entry?.url ?? info.baseUrl;
+    if (head === "ollama")
+        baseUrl = `${baseUrl.replace(/\/v1$/, "")}/v1`;
+    return { provider: head, api: info.api, model, baseUrl, apiKey, label: `${head}/${model}` };
+}