@tiens.nguyen/gonext-local-worker 1.0.330 → 1.0.333

package/gonext-local-worker.mjs

@@ -1768,6 +1768,75 @@ function _warmupPing(quiet) {
     });
 }
 
+// ─── Coding-backend resolution (task #117, folded into #123 Part B) ──────────────────
+// ONE answer to "which coding backend is this job using?", for the two decisions THIS
+// process makes before python starts: keep an Ollama model warm, and fetch the
+// OpenAI-compatible API key. The answer is passed down as `codingBackend` so python
+// doesn't re-derive it and can't disagree.
+//
+// The reference implementation is _resolve_coding_backend() in gonext_agent_chat.py —
+// it is pure and carries the offline resolution table (tests/test_backend_resolution.py).
+// Keep this rule in step with it: explicit kind wins → Ollama probe → remote ⇒ openai →
+// local. The probe runs BEFORE the remote rule so a remote Ollama box stays "ollama".
+
+// root → { value, until }. A YES is cached long (a box doesn't stop being Ollama), a NO
+// only briefly: "not Ollama" and "the probe failed" are indistinguishable here, so caching
+// a failure would strand a box that was merely booting/unreachable for one job.
+const _ollamaProbeCache = new Map();
+const _PROBE_TTL_YES_MS = 30 * 60_000;
+const _PROBE_TTL_NO_MS = 60_000;
+
+async function _probeIsOllama(baseURL) {
+  const root = String(baseURL || "").replace(/\/+$/, "").replace(/\/v1$/i, "");
+  if (!root) return false;
+  const hit = _ollamaProbeCache.get(root);
+  if (hit && hit.until > Date.now()) return hit.value;
+  let isOllama = false;
+  try {
+    // Ollama answers GET / with the plain-text banner "Ollama is running".
+    const res = await fetch(root, {
+      headers: { "User-Agent": "gonext-worker/1.0" },
+      signal: AbortSignal.timeout(6000),
+    });
+    isOllama = res.ok && /ollama/i.test((await res.text()).slice(0, 200));
+  } catch {
+    isOllama = false; // unreachable/TLS/404 → not provably Ollama
+  }
+  _ollamaProbeCache.set(root, {
+    value: isOllama,
+    until: Date.now() + (isOllama ? _PROBE_TTL_YES_MS : _PROBE_TTL_NO_MS),
+  });
+  return isOllama;
+}
+
+function _isLocalCodingUrl(baseURL) {
+  let host = "";
+  try {
+    host = new URL(String(baseURL || "")).hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return true; // unparseable → we are certainly not talking to a paid remote
+  }
+  if (!host) return true;
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (["localhost", "0.0.0.0", "::", "::1"].includes(host)) return true;
+  if (/^127(\.\d{1,3}){3}$/.test(host)) return true;
+  if (/^(10(\.\d{1,3}){3}|192\.168(\.\d{1,3}){2}|172\.(1[6-9]|2\d|3[01])(\.\d{1,3}){2}|169\.254(\.\d{1,3}){2})$/.test(host))
+    return true;
+  if (host.includes(":") && (host.startsWith("fe80:") || /^f[cd]/.test(host))) return true;
+  if (/\.(local|localdomain|lan|home|internal)$/.test(host)) return true;
+  // A dotless hostname ("mac-studio", "ollama1") is a LAN box: a public host always has a
+  // dot, and erring this way only ever means "don't expect an API key here".
+  return !host.includes(".") && !host.includes(":");
+}
+
+/** Resolve to "ollama" | "openai" | "local". `kind` is the user's Settings choice
+ *  ("ollama" | "openai" | "" = Auto). Only Auto costs a probe. */
+async function resolveCodingBackend(kind, baseURL) {
+  if (kind === "ollama" || kind === "openai" || kind === "local") return kind;
+  if (await _probeIsOllama(baseURL)) return "ollama";
+  return _isLocalCodingUrl(baseURL) ? "local" : "openai";
+}
+
 /**
  * Remember the agent's Ollama coding model (from a claimed agent_chat job) and keep it
  * resident via a background interval. Warms IMMEDIATELY only when the model is first
@@ -1801,19 +1870,34 @@ async function runAgentChatJob(job) {
   // "cancelled" status with completed/failed.
   const cancelAc = new AbortController();
   let cancelled = false;
-  // Remember this job's Ollama coding model and keep it resident via a background
-  // interval. Only warms now if the model is new/changed — repeat questions rely on
-  // the interval, so we don't re-warm (or re-log) on every question. The warm-up uses
-  // Ollama's native /api/generate, so SKIP it for an OpenAI-compatible coder (task #108):
-  // that endpoint doesn't exist there and we shouldn't hit a paid API with keep-warm pings.
-  if (payload?.codingKind !== "openai") {
-    trackCodingModelForWarmup(payload?.codingBaseURL ?? "", payload?.codingModelId ?? "");
-  }
+  // Task #108: the user's Coding backend setting ("ollama" | "openai" | "" = Auto).
+  const codingKind = ["ollama", "openai", "local"].includes(payload?.codingKind)
+    ? payload.codingKind
+    : "";
   const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
     method: "PATCH",
     body: JSON.stringify({ jobStatus: "running" }),
   });
   await ensureWorkerOk(runRes, `mark running agent_chat jobId=${jobId}`);
+  // Task #117/#123: `codingKind` above is the SETTING, not the answer — resolve the actual
+  // backend ONCE here and let both decisions below, plus python, read that one value.
+  // AFTER the "running" PATCH on purpose: an Auto config costs a probe (~6s worst case,
+  // then cached), and the REPL shouldn't watch a claimed job sit in "queued" for it.
+  const codingBackend = await resolveCodingBackend(codingKind, payload?.codingBaseURL ?? "");
+  console.log(
+    `[gonext-worker] agent job ${jobId}: coding backend ${codingBackend}` +
+      ` (kind=${codingKind || "auto"}, ${payload?.codingBaseURL || "no coding url"})`
+  );
+  // Remember this job's Ollama coding model and keep it resident via a background
+  // interval. Only warms now if the model is new/changed — repeat questions rely on
+  // the interval, so we don't re-warm (or re-log) on every question. The warm-up uses
+  // Ollama's native /api/generate, so it runs ONLY for an actual Ollama backend: on
+  // anything else that endpoint doesn't exist, and on a cloud one we'd be pinging a paid
+  // API every 4 minutes (which an Auto+cloud config did until #117 was fixed — the old
+  // gate only skipped an EXPLICIT openai kind).
+  if (codingBackend === "ollama") {
+    trackCodingModelForWarmup(payload?.codingBaseURL ?? "", payload?.codingModelId ?? "");
+  }
 
   let buf = "";
   let flushTimer = null;
@@ -1902,14 +1986,14 @@ async function runAgentChatJob(job) {
       jobActiveWorkspace = webWork;
     }
 
-    // Task #108: coding backend kind ("ollama" | "openai" | "" = Auto/sniff). For an
-    // OpenAI-compatible coder, fetch the API key from a dedicated worker-authed endpoint
-    // (NOT the job payload/Mongo doc — secret hygiene) and inject it into python stdin only.
-    const codingKind = payload?.codingKind === "ollama" || payload?.codingKind === "openai"
-      ? payload.codingKind
-      : "";
+    // Task #108: for an OpenAI-compatible coder, fetch the API key from a dedicated
+    // worker-authed endpoint (NOT the job payload/Mongo doc — secret hygiene) and inject
+    // it into python stdin only. Keyed off the RESOLVED backend (#117), so an Auto config
+    // pointing at a cloud endpoint now gets its key: it used to require the explicit
+    // "openai" kind, and python's `coding_api_key or agent_api_key` fallback then
+    // authenticated a cloud provider with the LOCAL agent key → 401.
     let codingApiKey = "";
-    if (codingKind === "openai") {
+    if (codingBackend === "openai") {
       try {
         const kr = await workerFetch("/api/worker/coding-key");
         if (kr.ok) {
@@ -1929,6 +2013,11 @@ async function runAgentChatJob(job) {
       codingBaseURL: payload?.codingBaseURL ?? "",
       codingModelId: payload?.codingModelId ?? "",
       codingKind,
+      // The resolved backend (#117): python trusts this instead of probing again, so the
+      // key fetch above and python's streaming / repair / step-budget branches can't
+      // disagree about what this endpoint is. Python re-resolves only if it ends up on a
+      // DIFFERENT url than the one judged here (its no-model-id fallback to the chat model).
+      codingBackend,
       codingApiKey,
       // Task #107: when true, python emits a {type:code_response} event per code-model
       // call so the worker persists the full raw text to Mongo.

package/gonext-repl.mjs

@@ -876,32 +876,52 @@ async function chooseModel() {
   }
   const allowed = Array.isArray(probe?.codingAllowed) ? probe.codingAllowed : [];
   const def = (probe?.codingDefault ?? "").trim();
-  if (allowed.length === 0) {
+  // Task #123: a choice is a (backend, model) PAIR — several backends (Ollama, an
+  // OpenAI-compatible endpoint, local MLX) can be enabled at once, and picking one moves
+  // the URL, the kind and the API key with it. `codingChoices` carries the backend of each
+  // entry so the list can say which is which; `codingAllowed` is the same ids, and stays
+  // the fallback for an API that predates this.
+  const choices = Array.isArray(probe?.codingChoices) && probe.codingChoices.length
+    ? probe.codingChoices
+    : allowed.map((id) => ({ id, model: id, kind: "" }));
+  if (choices.length === 0) {
     console.log(dim("  No coding model configured. Set one in the web app → Settings → Agent.\n"));
     return;
   }
-  if (allowed.length === 1) {
+  if (choices.length === 1) {
     console.log(
-      dim(`  Only one coding model is available: ${allowed[0]}.\n`) +
-        dim("  Add more in the web app → Settings → Agent → Load Models (checkboxes).\n")
+      dim(`  Only one coding model is available: ${choices[0].model}.\n`) +
+        dim("  Add more in the web app → Settings → Agent → Coding backends.\n")
     );
     return;
   }
   const active = sessionCodingModel || def;
-  // Arrow-key picker (↑/↓ + Enter) — pre-highlight the active model, tag the default.
-  const labels = allowed.map((m) => (m === def ? `${m}  (default)` : m));
-  const activeIdx = allowed.findIndex((m) => m === active);
+  // Arrow-key picker (↑/↓ + Enter) — pre-highlight the active model, tag the default, and
+  // name the backend when more than one is in play (the same model name can appear twice).
+  const KIND_LABEL = { ollama: "Ollama", openai: "OpenAI-compatible", local: "local MLX", "": "auto" };
+  const showKind = new Set(choices.map((c) => c.kind ?? "")).size > 1;
+  const labels = choices.map((c) => {
+    const kind = showKind ? `  ${dim(`· ${KIND_LABEL[c.kind ?? ""] ?? c.kind}`)}` : "";
+    return `${c.model}${kind}${c.id === def ? "  (default)" : ""}`;
+  });
+  const activeIdx = choices.findIndex((c) => c.id === active);
   console.log(dim("  Choose the coding model  (↑/↓ then Enter):"));
   const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0);
   if (idx < 0) {
     console.log(dim("  (cancelled)\n"));
     return;
   }
-  const chosen = allowed[idx];
+  const chosen = choices[idx];
   // Empty override means "use the account default" — so don't send an override when the
   // user picks the default (keeps the payload clean and lets a later default change win).
-  sessionCodingModel = chosen === def ? "" : chosen;
-  console.log(green(`  ✓ coding model → ${chosen}${chosen === def ? " (default)" : ""}\n`));
+  sessionCodingModel = chosen.id === def ? "" : chosen.id;
+  // Remember the friendly name for the token footer, which should never show a raw
+  // "<kind>::<model>" wire id.
+  sessionCodingLabel = chosen.id === def ? "" : chosen.model;
+  const where = showKind ? ` (${KIND_LABEL[chosen.kind ?? ""] ?? chosen.kind})` : "";
+  console.log(
+    green(`  ✓ coding model → ${chosen.model}${where}${chosen.id === def ? " (default)" : ""}\n`)
+  );
 }
 
 // Probe whether SSH KEY auth already works for a server (so we can tell the user to run
@@ -1252,7 +1272,12 @@ let jobIdForApprovalRace = "";
 
 // Per-session coding-model override chosen via /model (empty = use the account default).
 // Sent to /agent-ask as codingModelOverride; the API validates it against the whitelist.
+// Task #123: with several backends configured this is a QUALIFIED id ("<kind>::<model>"),
+// which resolves to a whole backend — URL, kind and API key — not just a model name.
 let sessionCodingModel = "";
+// The friendly model name behind sessionCodingModel, for display only: the token footer
+// must never show a raw "<kind>::<model>" wire id. Empty = running the account default.
+let sessionCodingLabel = "";
 // The default coding model id (from the startup agent-payload probe) — shown in the
 // per-turn token footer next to the GLOBAL output total so it's clear which model that
 // lifetime count belongs to. The /model override (sessionCodingModel) wins when set.
@@ -2383,7 +2408,7 @@ async function main() {
         // name so it's clear which coder that running total belongs to. Guard on THIS turn's
         // activity so a plain-reply greeting that did no code-model work shows nothing (#112).
         if ((inputTokens ?? 0) > 0 || (turnOutputTokens ?? 0) > 0) {
-          const coder = sessionCodingModel || defaultCodingModel;
+          const coder = sessionCodingLabel || defaultCodingModel;
           console.log(
             dim("tokens · ↑ in ") +
               fmtTokens(inputTokens ?? 0) +

package/gonext_agent_chat.py

@@ -879,6 +879,110 @@ def _is_ollama_server(base_url):
         return False
 
 
+# Loopback and RFC1918/link-local ranges — a URL on one of these is a box the user owns,
+# which is the whole point: only a REMOTE endpoint can plausibly need an API key.
+_LOOPBACK_RE = re.compile(r"^127(?:\.\d{1,3}){3}$")
+_PRIVATE_V4_RE = re.compile(
+    r"^(?:10(?:\.\d{1,3}){3}"
+    r"|192\.168(?:\.\d{1,3}){2}"
+    r"|172\.(?:1[6-9]|2\d|3[01])(?:\.\d{1,3}){2}"
+    r"|169\.254(?:\.\d{1,3}){2})$"
+)
+# mDNS / router-assigned search domains. A bare dotless hostname counts too (see below).
+_LOCAL_SUFFIXES = (".local", ".localdomain", ".lan", ".home", ".internal")
+
+
+def _is_local_url(base_url) -> bool:
+    """True when the base URL points at this machine or the local network.
+
+    Kept pure (no I/O) so the backend resolution table can be replayed offline. A dotless
+    hostname ("mac-studio", "ollama1") is treated as LAN: a public host effectively always
+    has a dot, and being wrong in that direction is the safe way — a LAN box is simply
+    never told to expect an API key.
+    """
+    host = _host_of(base_url)
+    if "@" in host:
+        host = host.rsplit("@", 1)[1]  # strip user:pass@
+    if host.startswith("["):
+        host = host[1:].split("]", 1)[0]  # [::1]:8080 → ::1
+    elif host.count(":") == 1:
+        host = host.rsplit(":", 1)[0]  # host:port → host
+    host = host.strip().lower().rstrip(".")
+    if not host:
+        return True  # no host at all → we are not talking to anyone remote
+    if host in ("localhost", "0.0.0.0", "::", "::1"):
+        return True
+    if _LOOPBACK_RE.match(host) or _PRIVATE_V4_RE.match(host):
+        return True
+    if ":" in host and (host.startswith("fe80:") or host[:2] in ("fc", "fd")):
+        return True  # IPv6 link-local / unique-local
+    if host.endswith(_LOCAL_SUFFIXES):
+        return True
+    return "." not in host and ":" not in host
+
+
+def _resolve_coding_backend(kind, base_url, probe=None):
+    """Answer "which coding backend is this?" ONCE. Returns (backend, why) where backend
+    is one of "ollama" | "openai" | "local" and `why` is log copy explaining the choice.
+
+    Task #117 (folded into #123). This used to be re-derived in three places from TWO
+    different questions — `coding_is_ollama` ("is this an Ollama server?", explicit kind
+    else a URL sniff) and `coding_kind == "openai"` ("did the user explicitly pick
+    OpenAI-compatible?") — and Auto fell between them: a cloud endpoint left on the
+    default Auto sniffed as not-Ollama and was not explicitly openai, so it got NEITHER
+    treatment (no streaming, none of the #113 reasoning repairs, and the small local step
+    budget). Every branch now keys off this one value.
+
+    Order matters. The Ollama probe runs BEFORE the remote-host rule so a remote Ollama
+    (ollama1.gomarsic.cc) still resolves to "ollama" and keeps its own treatment.
+
+        explicit kind                    → that value
+        probe says Ollama                → "ollama"
+        remote URL (not ours)            → "openai"   ← only a remote endpoint needs a key
+        otherwise                        → "local"    (an MLX box on 127.0.0.1)
+
+    Deliberately NOT keyed off "is an API key set": the Settings UI only renders the key
+    field once the OpenAI-compatible kind is picked, so on Auto the user cannot supply one
+    — a stored key there is only ever a leftover from switching the dropdown back, and
+    using it as the test would make the answer depend on that history.
+
+    `probe` is injectable so the resolution table can be replayed offline without network.
+    """
+    k = (kind or "").strip().lower()
+    if k in ("ollama", "openai", "local"):
+        return k, "explicit setting"
+    if (probe or _is_ollama_server)(base_url):
+        return "ollama", "auto: server answers as Ollama"
+    if not _is_local_url(base_url):
+        return "openai", "auto: remote URL, not Ollama"
+    return "local", "auto: local URL, not Ollama"
+
+
+def _coding_backend_flags(backend):
+    """Everything the resolved backend decides, derived in ONE place (task #117 → #123).
+
+    Pure, so the whole resolution → behaviour table can be replayed offline. The callers
+    below must not re-derive any of this from `coding_kind` or a URL sniff — that drift is
+    the bug this fixes.
+
+      ollama_tweaks — reasoning_effort='none' (Ollama's OpenAI-compat endpoint ignores
+                      Qwen3's /no_think but honors this) and the worker's keep-warm ping.
+      stream        — Ollama and remote OpenAI-compatible endpoints stream, so a long
+                      generation can't trip a proxy idle read-timeout and include_usage
+                      keeps output-token counting alive. Local MLX stays non-streaming.
+      openai_repairs— the #113 reasoning-model repairs (prose-only nudge, parse-error
+                      sanitizing, no-code streak breaker). Never applied to Ollama/MLX.
+      budget        — (default, workspace) step budget: a cloud coder is stronger and
+                      cheaper-per-step than a small local model, so it gets more room.
+    """
+    return {
+        "ollama_tweaks": backend == "ollama",
+        "stream": backend in ("ollama", "openai"),
+        "openai_repairs": backend == "openai",
+        "budget": (20, 40) if backend == "openai" else (10, 20) if backend == "ollama" else (5, 12),
+    }
+
+
 def _detect_model_id(base_url, api_key=""):
     """Ask an OpenAI-compatible server which model it serves (first reported id).
 
@@ -3509,11 +3613,12 @@ def run_agent_chat(cfg):
     raw_coding_base = _normalize_openai_base(cfg.get("codingBaseURL") or "")
     raw_coding_model = (cfg.get("codingModelId") or "").strip()
     # Task #108: explicit coding backend kind + API key for an OpenAI-compatible endpoint.
-    # coding_kind: "ollama" | "openai" | "" (Auto → sniff by URL). coding_api_key: the
-    # Bearer key for an OpenAI-compatible coder (empty otherwise). The key is used for the
-    # code-model calls (and coding-model auto-detect), NOT the chat model's agent_api_key.
+    # coding_kind: "ollama" | "openai" | "" — the USER'S SETTING, not the answer. What the
+    # branches read is `coding_backend` below, resolved once from this plus the URL.
+    # coding_api_key: the Bearer key for an OpenAI-compatible coder (empty otherwise). Used
+    # for the code-model calls (and coding-model auto-detect), NOT the chat agent_api_key.
     coding_kind = (cfg.get("codingKind") or "").strip().lower()
-    if coding_kind not in ("ollama", "openai"):
+    if coding_kind not in ("ollama", "openai", "local"):
         coding_kind = ""
     coding_api_key = (cfg.get("codingApiKey") or "").strip()
     # Task #107: when on, emit each code-model response so the worker persists it to Mongo.
@@ -3568,20 +3673,22 @@ def run_agent_chat(cfg):
     # local MLX keeps the original tight default). Overridable via cfg.maxSteps.
     # The provide_final_answer override below is only the exhaustion fallback.
     #
-    # Resolve the effective backend the SAME way as the model setup further down
-    # (explicit kind wins; Auto sniffs the URL) so the budgets match the coder that runs.
-    if coding_kind == "openai":
-        _budget_is_ollama = False
-    elif coding_kind == "ollama":
-        _budget_is_ollama = True
-    else:
-        _budget_is_ollama = _is_ollama_server(coding_base_url)
-    if coding_kind == "openai":
-        _default_budget, _ws_budget = 20, 40   # OpenAI-compatible coder
-    elif _budget_is_ollama:
-        _default_budget, _ws_budget = 10, 20    # Ollama coder
+    # THE ONE RESOLUTION (task #117 → #123 Part B). Everything that used to ask "is this
+    # Ollama?" or "did the user pick openai?" separately — reasoning_effort, streaming, the
+    # #113 reasoning repairs, and this step budget — now reads `coding_backend`.
+    #
+    # The worker (gonext-local-worker.mjs) resolves this first, because it must decide
+    # whether to fetch the coding API key BEFORE python starts, and passes the answer down
+    # as codingBackend. Trust it only when we ended up on the URL it judged: the fallbacks
+    # above can swap coding_base_url for the chat model's, which is a different server and
+    # may well be a different KIND of server.
+    _backend_hint = (cfg.get("codingBackend") or "").strip().lower()
+    if _backend_hint in ("ollama", "openai", "local") and coding_base_url == raw_coding_base:
+        coding_backend, _backend_why = _backend_hint, "resolved by the worker"
     else:
-        _default_budget, _ws_budget = 5, 12     # local MLX / Auto — original defaults
+        coding_backend, _backend_why = _resolve_coding_backend(coding_kind, coding_base_url)
+    coding_flags = _coding_backend_flags(coding_backend)
+    _default_budget, _ws_budget = coding_flags["budget"]
     try:
         max_steps = int(cfg.get("maxSteps") or _default_budget)
     except (TypeError, ValueError):
@@ -6268,25 +6375,16 @@ def run_agent_chat(cfg):
         # the live test — minutes per step on a slow GPU — so disable it explicitly.
         # Sniffed per-server because MLX might reject the unknown param.
         extra_model_kwargs = {}
-        # Task #108: the explicit backend kind (from web Settings) OVERRIDES the URL-sniff.
-        # Auto ("") → sniff by URL (today's behavior; correctly False for MLX). Only Ollama
-        # gets reasoning_effort='none' (MLX/OpenAI reject or don't need it).
-        if coding_kind == "ollama":
-            coding_is_ollama = True
-        elif coding_kind == "openai":
-            coding_is_ollama = False
-        else:
-            coding_is_ollama = _is_ollama_server(coding_base_url)
-        if coding_is_ollama:
+        # `coding_backend` was resolved once, above, and `coding_flags` derives everything
+        # from it — do NOT re-derive any of this from the kind or a URL sniff here.
+        if coding_flags["ollama_tweaks"]:
             _log("coding server is Ollama → reasoning_effort='none' (disable thinking) + streaming")
             extra_model_kwargs["reasoning_effort"] = "none"
-        # Stream for Ollama AND for OpenAI-compatible remotes (task #108/#104): a remote
-        # endpoint behind a proxy hits the same idle read-timeout streaming avoids, and
-        # stream_options.include_usage keeps output-token counting working. Only a LOCAL
-        # MLX coder (Auto, non-ollama) stays non-streaming.
-        _stream_coder = coding_is_ollama or coding_kind == "openai"
-        _log(f"coding backend: kind={coding_kind or 'auto'} ollama={coding_is_ollama} "
-             f"stream={_stream_coder} key={'yes' if coding_api_key else 'no'}")
+        _stream_coder = coding_flags["stream"]
+        _log(f"coding backend: {coding_backend} ({_backend_why}; "
+             f"kind={coding_kind or 'auto'}, {_host_of(coding_base_url)}) "
+             f"stream={_stream_coder} steps={max_steps} "
+             f"key={'yes' if coding_api_key else 'no'}")
         model = _LoggingModel(
             model_id=coding_model_id,
             api_base=coding_base_url,
@@ -6299,9 +6397,12 @@ def run_agent_chat(cfg):
             # Task #107: persist each code-model response to Mongo when the user opted in.
             save_full_response=save_full_response,
             # Task #113: enables the reasoning-model repairs (prose-only nudge, parse-error
-            # sanitizing, no-code breaker). Explicit kind=openai ONLY — Ollama and Auto/MLX
-            # never take those branches.
-            openai_backend=(coding_kind == "openai"),
+            # sanitizing, no-code breaker). Gated to the OpenAI-compatible backend — Ollama
+            # and local MLX never take those branches. #113 gated this on the EXPLICIT
+            # kind; the intent (don't touch Ollama) is unchanged, but an Auto+cloud config
+            # now resolves to "openai" instead of "local", so it finally gets the repairs
+            # it was always meant to have.
+            openai_backend=coding_flags["openai_repairs"],
             # Cap each HTTP attempt at 600s so a genuinely slow single call (a
             # remote M6000/Vulkan box doing a cold ~4-5min prompt-eval) can finish
             # on the first try, while a truly hung request still fails into OUR

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.330",
+  "version": "1.0.333",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",