@tiens.nguyen/gu-cli 1.0.699 → 1.0.700

package/agent-model-command.mjs

@@ -349,3 +349,70 @@ 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.",
+      ];
+}

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/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 }
+      ),
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.699",
+  "version": "1.0.700",
   "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",