@tiens.nguyen/gu-cli 1.0.699 → 1.0.701

package/agent-model-command.mjs

@@ -349,3 +349,120 @@ export function agentRecoveryOptions({ keyProblem = false, host = "" } = {}) {
     { action: "provider", label: "add an OpenAI-compatible provider for the agent…" },
   ];
 }
+
+// ---------------------------------------------------------------------------------------------
+// #43 — /model's "change the Ollama server" flow, when the agent is NOT on an Ollama.
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * Is this machine's agent model on an OpenAI-compatible PROVIDER rather than an Ollama?
+ *
+ * Reported (#43): client mode, /model → change the Ollama server offered the agent's URL —
+ * https://api.openai.com — as the "agent + embedding server", probed it for Ollama's /api/tags, got
+ * 404, said "check that Ollama is listening", and asked again, with no way forward but typing "no".
+ * A provider is known two ways: a provider row for that URL says so, or the URL is one of the hosted
+ * APIs everyone knows is not an Ollama.
+ */
+const KNOWN_PROVIDER_HOSTS = [
+  "api.openai.com",
+  "openrouter.ai",
+  "api.together.xyz",
+  "api.moonshot.ai",
+  "api.groq.com",
+  "api.deepseek.com",
+  "api.mistral.ai",
+  "generativelanguage.googleapis.com",
+];
+
+export function agentIsOnProvider(settings) {
+  const source = agentListSource(settings);
+  if (!source.url) return false;
+  if (source.dialect === "openai") return true;
+  let host = "";
+  try {
+    host = new URL(String(settings?.agentModelUrl ?? "")).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return KNOWN_PROVIDER_HOSTS.some((h) => host === h || host.endsWith(`.${h}`));
+}
+
+/**
+ * The address to offer for the CODING server: the coder's own URL when it is not a known provider,
+ * else this machine's Ollama. Never the agent's provider URL — that is what put api.openai.com in an
+ * Ollama prompt.
+ */
+export function coderServerDefault(settings) {
+  const coder = String(settings?.agentCodingModelUrl ?? "").trim();
+  if (coder && !agentIsOnProvider({ ...settings, agentModelUrl: coder })) return coder;
+  const agent = String(settings?.agentModelUrl ?? "").trim();
+  if (agent && !agentIsOnProvider(settings)) return agent;
+  return "http://127.0.0.1:11434";
+}
+
+/**
+ * A server that ANSWERED but has no /api/tags is not an Ollama — an OpenAI-compatible API answers 404
+ * there. That is a different fix from "not listening", and saying the wrong one sends people to check
+ * a server that is working fine.
+ */
+export function describeNotOllama(host, role) {
+  return role === "agent"
+    ? [
+        `${host} answers, but it is not an Ollama server (no /api/tags).`,
+        "an OpenAI-compatible agent is changed with /agent-model — or type 'no' to skip this role.",
+      ]
+    : [
+        `${host} answers, but it is not an Ollama server (no /api/tags).`,
+        "for an OpenAI-compatible coder use /model → add or change an OpenAI-compatible provider — or type 'no' to skip.",
+      ];
+}
+
+// ---------------------------------------------------------------------------------------------
+// #44 — WHAT TO CHANGE comes first.
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The first screen of /agent-model: what to change, before any model list.
+ *
+ * Reported (#44): client mode, agent on api.openai.com — /agent-model opened straight onto "130 on
+ * https://api.openai.com/v1" with the current model selected, and the ways to use an Ollama server
+ * or another provider sat after all 130 rows. Enter said "already using gpt-4.1-mini — nothing
+ * changed", and the only thing the screen seemed to allow was another OpenAI model. First-time setup
+ * worked; changing it afterwards did not look possible.
+ *
+ * So the choice of WHAT to change is its own short list, in the order it is most often wanted. The
+ * key entry appears only where a key applies. Returns [{ action, label }].
+ */
+export function agentMenuOptions({ host = "", modelCount = 0, needsKey = false } = {}) {
+  const where = host || "this server";
+  return [
+    { action: "models", label: `pick another model on ${where}${modelCount ? `  (${modelCount})` : ""}` },
+    { action: "ollama", label: "use an Ollama server for the agent…" },
+    { action: "provider", label: "use another OpenAI-compatible provider…" },
+    ...(needsKey ? [{ action: "key", label: `enter a new API key for ${where}…` }] : []),
+  ];
+}
+
+/**
+ * The providers already saved on this machine that the agent could switch to — OpenAI-compatible
+ * rows, current one marked — then "add a new one". Switching to a provider you already set up must
+ * not mean typing its URL again. Returns [{ action: "row" | "add", row?, label }].
+ */
+export function agentProviderChoices(settings) {
+  const rows = Array.isArray(settings?.agentCodingBackends) ? settings.agentCodingBackends : [];
+  const current = ensureV1Root(String(settings?.agentModelUrl ?? "")).toLowerCase();
+  const out = [];
+  for (const row of rows) {
+    if (!row || row.kind !== "openai" || !row.url) continue;
+    let host = String(row.url);
+    try {
+      host = new URL(String(row.url)).host;
+    } catch {
+      /* keep the raw url */
+    }
+    const isCurrent = ensureV1Root(String(row.url)).toLowerCase() === current;
+    out.push({ action: "row", row, label: `${host}${isCurrent ? "  (current)" : ""}` });
+  }
+  out.push({ action: "add", label: "add a new OpenAI-compatible provider…" });
+  return out;
+}

package/client-expert-api.mjs

@@ -734,3 +734,37 @@ export async function seedSettings({
     await client.close().catch(() => {});
   }
 }
+
+/**
+ * THE NEW OLLAMA SERVER'S ROWS, MERGED INTO WHAT IS ALREADY THERE — never replacing it (#43).
+ *
+ * Found while fixing #43: choosing a coding server in /model → "change the Ollama server" saved
+ * codingBackendsForClientExpert(...) AS the whole list — one Ollama row and the Kimi row — deleting
+ * every provider the user had added: an api.openai.com row the AGENT's key is found through, an
+ * ollama.com cloud row. Their keys, bound to those row ids, were orphaned.
+ *
+ * Replaced: the local/LAN Ollama row(s) — that is what "the Ollama server this machine uses" means —
+ * with the new one, which keeps the first replaced row's id so anything bound to it still resolves.
+ * Kept, ids and all: every OpenAI-compatible row, and any Ollama CLOUD row (a paid provider, not
+ * "this machine's server"). The template's default provider row is added only when no row already
+ * has its URL.
+ */
+export function mergeOllamaServerBackends(existing, fresh, { isCloud } = {}) {
+  const cloud = typeof isCloud === "function" ? isCloud : () => false;
+  const norm = (u) => String(u ?? "").trim().replace(/\/+$/, "").toLowerCase();
+  const rows = Array.isArray(existing) ? existing.filter(Boolean) : [];
+  const replaced = rows.filter((b) => b.kind === "ollama" && !cloud(b.url));
+  const kept = rows.filter((b) => !(b.kind === "ollama" && !cloud(b.url)));
+  const out = [];
+  for (const f of Array.isArray(fresh) ? fresh : []) {
+    if (f.kind === "ollama") {
+      const id = replaced.find((b) => b.id)?.id;
+      out.push(id ? { ...f, id } : f);
+    }
+  }
+  out.push(...kept);
+  for (const f of Array.isArray(fresh) ? fresh : []) {
+    if (f.kind !== "ollama" && !out.some((b) => norm(b.url) === norm(f.url))) out.push(f);
+  }
+  return out;
+}

package/gonext_agent_chat.py

@@ -9694,22 +9694,25 @@ def run_agent_chat(cfg):
                                     f"{_host} refused: "
                                     + (_why or "the account is out of credit")
                                     + ". Nothing ran — top up the account, or switch the "
-                                    "coding model in Settings → Agent."
+                                    "coding model (in gu: /model; on the web: Settings → Agent)."
                                 ) from e
+                            # THE TERMINAL WAY FIRST (#44): a client-mode machine has no web app,
+                            # so "Settings → Agent" alone was advice it could not follow.
                             if coding_api_key:
                                 raise _AgentConfigError(
                                     f"The agent coding backend ({_host}) REJECTED the "
-                                    "coding API key. Nothing ran. Re-enter 'Agent coding "
-                                    "model API key' in Settings → Agent (the stored key is "
-                                    "write-only, so a stale one can't be inspected — just "
-                                    "save a fresh one)."
+                                    "coding API key. Nothing ran. Enter a fresh key — in gu: "
+                                    "press ctrl+k (or /model → the provider); on the web: "
+                                    "Settings → Agent. The stored key is write-only, so a "
+                                    "stale one can't be inspected — just save a fresh one."
                                 ) from e
                             raise _AgentConfigError(
                                 f"The agent coding backend ({_host}) rejected the request: "
                                 "NO coding API key was sent, so the local agent key was "
-                                "used instead. Enter the API key in Settings → Agent for "
-                                "this coding backend (OpenAI-compatible, or Ollama with an "
-                                "https://ollama.com URL — local Ollama needs no key)."
+                                "used instead. Enter the API key for this coding backend — in "
+                                "gu: press ctrl+k; on the web: Settings → Agent "
+                                "(OpenAI-compatible, or Ollama with an https://ollama.com URL — "
+                                "local Ollama needs no key)."
                             ) from e
                         if "404" in emsg and "not found" in emsg.lower():
                             # Probe with the CODING key when there is one: using the agent

package/gu-repl.mjs

@@ -4721,12 +4721,13 @@ async function reconfigureOllamaServer() {
     const res = await withPendingStatus(`loading models from ${n.host}`, () =>
       proxyFetch(os.tagsUrlFor(n), { signal: AbortSignal.timeout(8000) })
     );
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    // The status is kept: a 404 here means "answered, but not an Ollama" (#43), not "unreachable".
+    if (!res.ok) throw Object.assign(new Error(`HTTP ${res.status}`), { httpStatus: res.status });
     return am.parseOllamaTags(await res.json().catch(() => null));
   };
 
   /** Ask for one server and load it. Returns {normalized, models} or null (declined/failed). */
-  const askServer = async (label, dflt, { require = false, short = "server" } = {}) => {
+  const askServer = async (label, dflt, { require = false, short = "server", role = "coder" } = {}) => {
     for (let attempt = 0; attempt < 3; attempt++) {
       // The address goes ABOVE, in full — it is long, it is the thing Enter accepts, and the
       // frozen row is too narrow to hold it without truncating exactly that. The row itself
@@ -4766,6 +4767,12 @@ async function reconfigureOllamaServer() {
         }
       }
       if (!n) {
+        if (lastErr?.httpStatus === 404) {
+          // IT ANSWERED — it is simply not an Ollama (#43). "Couldn't reach … is Ollama listening"
+          // sent people to debug a server that was working.
+          for (const l of am.describeNotOllama(candidates[0].host, role)) console.log(yellow(`  ${l}`));
+          continue;
+        }
         // One address typed, one failure reported — naming every candidate would be two errors
         // for one mistake, and neither would be the address they gave.
         console.log(red(`  couldn't reach ${candidates[0].host}: ${os.networkReason(lastErr)}`));
@@ -4795,18 +4802,31 @@ async function reconfigureOllamaServer() {
     return null;
   };
 
+  // AN AGENT ON A PROVIDER IS NOT ASKED ABOUT HERE (#43). This flow is for Ollama boxes; offering
+  // https://api.openai.com as the "agent + embedding server" could only fail its /api/tags probe and
+  // ask again. Keep it, say where it is changed, and go on to the coder.
+  const agentOnProvider = am.agentIsOnProvider(settings);
   const curAgent =
     String(settings.agentModelUrl ?? "").trim() || "https://ollama1.gomarsic.cc/v1";
-  const curCode = String(settings.agentCodingModelUrl ?? "").trim() || curAgent;
+  const curCode = am.coderServerDefault(settings);
 
-  console.log(dim("  TWO servers may be used: the agent + embedder on one, the coder on another."));
-  console.log(dim("  Enter keeps the current address; type 'no' to skip a role."));
-  const agent = await askServer("Agent + embedding server", curAgent, {
-    require: true,
-    short: "agent + embed server",
-  });
+  let agent = null;
+  if (agentOnProvider) {
+    const host = hostOf(String(settings.agentModelUrl ?? ""));
+    console.log(dim(`  The agent model is on ${host} (OpenAI-compatible) — kept as it is; change it with /agent-model.`));
+    console.log(dim("  Enter keeps the current address; type 'no' to skip."));
+  } else {
+    console.log(dim("  TWO servers may be used: the agent + embedder on one, the coder on another."));
+    console.log(dim("  Enter keeps the current address; type 'no' to skip a role."));
+    agent = await askServer("Agent + embedding server", curAgent, {
+      require: true,
+      short: "agent + embed server",
+      role: "agent",
+    });
+  }
   const coder = await askServer("Coding-model server", agent?.normalized?.url ?? curCode, {
     short: "coding server",
+    role: "coder",
   });
 
   if (!agent && !coder) {
@@ -4912,12 +4932,18 @@ async function reconfigureOllamaServer() {
       agentCodingModelName: code,
       agentCodingModelKind: "ollama",
       agentCodingDefaultKind: "ollama",
-      agentCodingBackends: (await import("./client-expert-api.mjs")).codingBackendsForClientExpert({
-        url: coder.normalized.url,
-        chat: agent ? chat : code,
-        code,
-        altCoders: extras,
-      }),
+      // MERGED, not replaced (#43): the providers already configured — and the keys bound to them —
+      // survive choosing a new Ollama server.
+      agentCodingBackends: (await import("./client-expert-api.mjs")).mergeOllamaServerBackends(
+        (await import("./coding-provider-setup.mjs")).existingBackendRows(settings),
+        (await import("./client-expert-api.mjs")).codingBackendsForClientExpert({
+          url: coder.normalized.url,
+          chat: agent ? chat : code,
+          code,
+          altCoders: extras,
+        }),
+        { isCloud: (await import("./coding-key-prompt.mjs")).isOllamaCloudUrl }
+      ),
     });
   }
 
@@ -6093,6 +6119,29 @@ async function pointAgentAtProvider(row, host) {
   await saveAgentModel(url, model, host);
 }
 
+/**
+ * #44: switch the agent to a provider already saved on this machine, or add a new one.
+ */
+async function chooseAgentProvider() {
+  const am = await import("./agent-model-command.mjs");
+  const settings = await withPendingStatus("reading your providers", fetchWorkerSettings);
+  if (!settings) {
+    console.log(red("  couldn't reach the API to read your providers.\n"));
+    return;
+  }
+  const choices = am.agentProviderChoices(settings);
+  if (choices.length === 1) return addCodingProvider("agent");
+  console.log(dim(`  Which OpenAI-compatible provider should the agent use?  (${PICK_HINT})`));
+  const idx = await pickFromList(choices.map((c) => c.label), 0);
+  if (idx < 0) {
+    console.log(dim("  (cancelled)\n"));
+    return;
+  }
+  const pick = choices[idx];
+  if (pick.action === "add") return addCodingProvider("agent");
+  await pointAgentAtProvider(pick.row, hostOf(String(pick.row.url ?? "")));
+}
+
 /**
  * #41: the agent model on an OLLAMA server — this machine's, a LAN box, or the Ollama cloud.
  *
@@ -6308,6 +6357,21 @@ async function chooseAgentModel() {
     return;
   }
 
+  // WHAT TO CHANGE, FIRST (#44). The ways to use an Ollama server or another provider used to sit
+  // after every model on this one — 130 rows down on api.openai.com — which read as "OpenAI models
+  // are all you can choose". A short menu of what to change comes before any list.
+  console.log(dim(`  Agent model — the one that TALKS: ${current || "unset"} on ${listHost}`));
+  const menu = am.agentMenuOptions({ host: listHost, modelCount: models.length, needsKey });
+  const first = await pickFromList(menu.map((o) => o.label), 0);
+  const firstAction = first >= 0 ? menu[first].action : "cancel";
+  if (firstAction === "cancel") {
+    console.log(dim("  (cancelled)\n"));
+    return;
+  }
+  if (firstAction === "ollama") return addOllamaAgent();
+  if (firstAction === "provider") return chooseAgentProvider();
+  if (firstAction === "key") return enterAgentProviderKey(source.row, listHost);
+
   const rows = am.agentModelRows(models, current);
   console.log(dim(`  Agent model — the one that TALKS  (currently ${current || "unset"})`));
   // Strip whichever list endpoint was asked, so the header names the SERVER rather than the path.
@@ -6334,28 +6398,13 @@ async function chooseAgentModel() {
       (r.current ? accent("  (current)") : "")
     );
   });
-  // APPENDED LAST, after every model, for the reason #223 records: a new entry must never shift
-  // an index someone already has muscle memory for. Offered even when the list is healthy,
-  // because "which model on the box I am pointed at" and "I want a different provider" are
-  // different questions, and only the first is answered by the rows above.
-  labels.push("add an OpenAI-compatible provider for the agent…");
-  // #41, appended AFTER the provider entry so no existing index moves.
-  labels.push("use an Ollama server for the agent…");
+  // No other entries here any more (#44): the ways to change the provider are on the menu above,
+  // where they can be seen, rather than after every model.
   const idx = await pickFromList(labels, Math.max(0, rows.findIndex((r) => r.current)));
   if (idx < 0) {
     console.log(dim("  (cancelled)\n"));
     return;
   }
-  // labels is now TWO LONGER than rows. Reading rows[idx] for an appended entry would
-  // dereference undefined and take the picker down, so they are answered before rows is touched.
-  if (idx === rows.length) {
-    await addCodingProvider("agent");
-    return;
-  }
-  if (idx === rows.length + 1) {
-    await addOllamaAgent();
-    return;
-  }
   const chosen = rows[idx].model;
   if (chosen === current) {
     console.log(dim(`  already using ${current} — nothing changed.\n`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.699",
+  "version": "1.0.701",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",