@tiens.nguyen/gonext-local-worker 1.0.328 → 1.0.332

package/gonext-local-worker.mjs

@@ -1768,6 +1768,76 @@ 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") return "ollama";
+  if (kind === "openai") return "openai";
+  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 +1871,33 @@ 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 =
+    payload?.codingKind === "ollama" || payload?.codingKind === "openai" ? 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_agent_chat.py

@@ -879,6 +879,112 @@ 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 == "ollama":
+        return "ollama", "explicit setting"
+    if k == "openai":
+        return "openai", "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).
 
@@ -1528,6 +1634,49 @@ def _is_backend_overloaded(err) -> bool:
     )
 
 
+def _is_auth_failure(err) -> bool:
+    """True when the model server REJECTED OUR CREDENTIAL — a deterministic config error
+    that must fail fast rather than retry (task #117 companion).
+
+    Deliberately narrow:
+      • 401 is always an auth failure.
+      • 403 is NOT, on its own. Several providers return 403 for QUOTA EXHAUSTED as well as
+        for permission-denied, and reporting "you're out of credit" as "your API key is
+        wrong" sends the user to fix the wrong thing. A 403 counts only when the body does
+        NOT read like a quota/rate problem — those belong to _is_backend_overloaded.
+      • 402 (payment required) is a billing problem, not a credential one — excluded here
+        so it can carry its own message.
+    Falls back to message text only when the exception carries no HTTP status (a bare
+    string, or a wrapper that lost its cause)."""
+    if _is_backend_overloaded(err):
+        return False  # a 429 (or a quota-flavoured 403) is never an auth failure
+    s = str(err or "").lower()
+    code = _http_status_of(err)
+    if code is not None:
+        if code == 401:
+            return True
+        if code == 403:
+            return not re.search(r"quota|rate.?limit|billing|credit|capacity", s)
+        return False
+    return (
+        "401" in s
+        or "invalid_api_key" in s
+        or "invalid api key" in s
+        or "incorrect api key" in s
+        or "unauthorized" in s
+        or "authentication" in s and "fail" in s
+    )
+
+
+def _is_billing_failure(err) -> bool:
+    """True for 402 / explicit out-of-credit responses — deterministic like an auth failure
+    but with a different fix, so it gets its own message instead of 'check your API key'."""
+    if _http_status_of(err) == 402:
+        return True
+    s = str(err or "").lower()
+    return "insufficient_quota" in s or "exceeded your current quota" in s
+
+
 def _retry_after_seconds(err):
     """The provider's Retry-After hint in seconds, or None. Reads the header off an
     openai-python APIStatusError (`err.response.headers`) and falls back to a
@@ -1862,12 +2011,68 @@ def _looks_like_tool_code(code: str):
     return True, ""
 
 
+_CODE_PAIR_RE = r"<code[^>]*>[\s\S]*?</code>"
+
+
+def _close_dangling_code_block(text):
+    """Close a code block the model OPENED but never CLOSED, when what follows it is a
+    runnable tool call — the normal shape whenever the server honors `stop` (task #119).
+
+    smolagents appends its closing tag to the stop_sequences of every CodeAgent turn
+    (agents.py: `stop_sequences.append(self.code_block_tags[1])`), so any backend that
+    honors `stop` — i.e. every OpenAI-compatible API — returns the block WITHOUT its
+    closer. Confirmed against the raw responses saved from a live run: what the model
+    actually sends is `<code>\\nrun_command("npm run build", …)` and nothing after it.
+    smolagents re-appends the tag itself once it has the text (agents.py, "This adds the
+    end code sequence … to the history"), which is why a trace shows a tidy `…</code>`
+    that never came off the wire — but every check WE run in between tested for the PAIR
+    `<code>…</code>`, a delimiter this backend structurally cannot produce.
+
+    What that cost, live: a perfectly good turn was read as a "dangling code tag", burned
+    a second model call on the CODE-NOW retry, and the retry's equally good opener-only
+    reply was then DISCARDED for failing the same pair test — so every other step died on
+    a parse error the model never caused, while the user watched "Error in code parsing"
+    scroll past on steps that had in fact called the right tool.
+
+    So: canonicalize first, decide second. Everything after the LAST opener is taken as
+    the block, a trailing "Thought:" line and stray tags are cut, and the result is
+    substituted ONLY when _looks_like_tool_code passes (it compiles AND calls something)
+    — the same #113 validity gate used for reasoning-channel recovery, so prose that
+    merely trails a stray tag is never promoted into executable code.
+
+    No-op when the text already holds a pair, has no opener, or the tail isn't runnable;
+    idempotent. Deliberately backend-agnostic: `stop` truncation is a property of the
+    protocol, not of one vendor, and the gate makes it inert everywhere else."""
+    if not isinstance(text, str) or not text:
+        return text
+    if re.search(_CODE_PAIR_RE, text, re.I):
+        return text                      # a real block already — never touch it
+    opens = list(re.finditer(r"<code[^>]*>", text, re.I))
+    if not opens:
+        return text                      # prose turn, or a lone stray closer (see #111)
+    last = opens[-1]
+    body = re.split(r"\n\s*Thought\s*:\s", text[last.end():], maxsplit=1)[0]
+    body = re.sub(r"</?code[^>]*>", "", body, flags=re.I).strip()
+    ok, _why = _looks_like_tool_code(body)
+    if not ok:
+        return text                      # not runnable — leave the step to fail honestly
+    # Keep the Thought prose that preceded the block, minus any earlier stray tag (an
+    # unbalanced opener left in the head would let the pair regex start from the wrong
+    # place and swallow the prose into the code).
+    head = re.sub(r"</?code[^>]*>", "", text[:last.start()], flags=re.I).rstrip()
+    return (head + "\n" if head else "") + "<code>\n" + body + "\n</code>"
+
+
 def _has_runnable_block(text) -> bool:
     """True if `text` contains a <code>…</code> block whose python actually compiles —
     i.e. this step produced something that can run. Used by the #113 no-code loop-breaker
-    (openai backend only) to tell "the step worked" from "the model wrote prose again"."""
+    (openai backend only) to tell "the step worked" from "the model wrote prose again".
+
+    Closes a stop-truncated block first (#119), so a step that DID call a tool is never
+    counted toward the no-code streak just because the API ate the closing tag."""
     if not isinstance(text, str) or not text:
         return False
+    text = _close_dangling_code_block(text)
     blk = re.search(r"<code[^>]*>([\s\S]*?)</code>", text, re.I)
     if not blk:
         return False
@@ -1884,7 +2089,10 @@ def _code_nudge_reason(content, openai_backend: bool):
     replayed offline against real traces (task #113).
 
       1. empty-content   — the whole turn went to the reasoning channel, no message.
-      2. dangling tag    — a stray <code>/</code> with no valid pair.
+      2. dangling tag    — a stray <code>/</code> with no valid pair. A block the server
+         merely TRUNCATED at the `</code>` stop sequence is not that (task #119): it is
+         closed first and accepted as-is, so a step that already called a tool no longer
+         pays for a second model call to be told to do what it just did.
       3. prose-only plan — narration of what it is ABOUT to do, no tag at all. This one
          is openai-only and additionally requires _looks_like_scratchpad, so a FINISHED
          prose answer is never nudged into inventing another tool call. It exists because
@@ -1896,8 +2104,8 @@ def _code_nudge_reason(content, openai_backend: bool):
     text = (content or "").strip()
     if not text:
         return "empty-content"
-    if re.search(r"<code[^>]*>[\s\S]*?</code>", content, re.I):
-        return None  # a real block — nothing to nudge
+    if re.search(_CODE_PAIR_RE, _close_dangling_code_block(content), re.I):
+        return None  # a real block (closing a stop-truncated one first) — nothing to nudge
     if re.search(r"</?code[\s>/]", content, re.I):
         return "dangling code tag, no valid block"
     if openai_backend and _looks_like_scratchpad(text):
@@ -1922,9 +2130,12 @@ def _recover_code_from_reasoning(content, reasoning):
     Candidates are tried NEWEST-first and the first runnable one wins; if none is
     runnable we return `content` untouched and let the step fail normally, which
     is what happened before #111 existed."""
-    _pair = r"<code[^>]*>[\s\S]*?</code>"
-    if re.search(_pair, content or "", re.I):
-        return content  # content already has a usable block — never override it
+    _pair = _CODE_PAIR_RE
+    if re.search(_pair, _close_dangling_code_block(content) or "", re.I):
+        # Content already has a usable block — never override it. A block the server
+        # truncated at the `</code>` stop sequence counts as usable (#119): the visible
+        # channel is the model's actual answer and must win over a reasoning-channel draft.
+        return content
     reasoning = reasoning or ""
     if not reasoning.strip():
         return content  # nothing to recover from (Ollama / non-reasoning model)
@@ -3404,9 +3615,10 @@ 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"):
         coding_kind = ""
@@ -3463,20 +3675,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):
@@ -5326,6 +5540,14 @@ def run_agent_chat(cfg):
                     _log(f"streamed generate refused ({_clip(str(e), 200)}) → NOT falling "
                          "back to non-streaming; letting the retry loop back off (#114)")
                     raise
+                if _is_auth_failure(e) or _is_billing_failure(e):
+                    # Same reasoning as the overload above: the credential was rejected, so
+                    # streaming was never the problem. Re-sending unstreamed would cost a
+                    # second identical request per attempt AND print "Streaming unavailable
+                    # — retrying without streaming…", which is simply untrue here.
+                    _log(f"streamed generate rejected ({_clip(str(e), 200)}) → NOT falling "
+                         "back to non-streaming; this is a credential/billing error")
+                    raise
                 _log(f"streamed generate failed ({e}) → falling back to non-streaming")
                 _emit({"type": "step",
                        "text": "Streaming unavailable — retrying without streaming…"})
@@ -5457,6 +5679,12 @@ def run_agent_chat(cfg):
                 _emit({"type": "step", "text": "Model output ran away — restarting this step…"})
                 _log(f"streamed generate: discarded {len(content)} runaway chars → empty content")
                 return "", role, in_tok, out_tok, reasoning_len
+            # Task #119: smolagents passes its closing "</code>" as a stop sequence, so a
+            # server that honors `stop` returns the block UNCLOSED. Close it here, before
+            # anything downstream asks "did this turn produce a code block?" — otherwise a
+            # step that called a tool correctly reads as broken. Gated on the code actually
+            # compiling, so a genuinely dangling tag still falls through to the nudge below.
+            content = _close_dangling_code_block(content)
             # Task #111: reasoning models on an OpenAI-compatible API (e.g. Kimi K3 @ Moonshot)
             # can emit the actionable <code>…</code> into the REASONING channel, leaving only
             # prose + a stray tag in `content` → smolagents' parser can't find the pair. When
@@ -5522,7 +5750,11 @@ def run_agent_chat(cfg):
             #       in the trace is appended by SMOLAGENTS after we return (its stop-sequence
             #       handling), so the content WE see here carries no tag at all. Openai-only.
             # See _code_nudge_reason for the full decision (kept pure so it can be replayed).
-            _pair_re = r"<code[^>]*>[\s\S]*?</code>"
+            # NOTE (#119): none of these triggers may fire on a block the server merely
+            # truncated at the "</code>" stop sequence — that is the SUCCESS shape for an
+            # OpenAI-compatible backend, not a failure. _close_dangling_code_block runs in
+            # _run_stream (and again inside _code_nudge_reason) so it is already excluded.
+            _pair_re = _CODE_PAIR_RE
             why = _code_nudge_reason(content, self._openai_backend)
             if why:
                 _log(f"{why} turn (reasoning={reasoning_len} chars) → retrying once with a "
@@ -5534,7 +5766,13 @@ def run_agent_chat(cfg):
                     {"role": "user", "content": self._CODE_NOW_DIRECTIVE}
                 ]
                 r_content, r_role, r_in, r_out, _ = self._run_stream(retry_kwargs)
-                r_has_pair = re.search(_pair_re, r_content or "", re.I) is not None
+                # Close a stop-truncated block before judging the retry (#119). This test
+                # used to demand a literal pair, which the openai backend cannot return —
+                # so the retry we had just paid for was thrown away and the broken original
+                # was sent on to smolagents. (_run_stream already closed it; the call here
+                # is idempotent and keeps the rule visible at the point of decision.)
+                r_has_pair = re.search(
+                    _pair_re, _close_dangling_code_block(r_content) or "", re.I) is not None
                 # Use the retry when it yields a real code block, or (empty original) any
                 # content. If the retry is still broken and we HAD a Thought, keep the
                 # original and let smolagents' own retry take it from here — no regression.
@@ -5545,7 +5783,13 @@ def run_agent_chat(cfg):
                 out_tok += r_out
             if stop_sequences and not self.supports_stop_parameter:
                 from smolagents.models import remove_content_after_stop_sequences
+                # For a server that can't honor `stop`, smolagents emulates it by splitting
+                # on each stop sequence and keeping split[0] — and "</code>" IS one of those
+                # sequences, so this CUTS THE CLOSER back off a block that had one. Re-close
+                # afterwards (#119) so both kinds of backend hand back the same canonical
+                # shape; without it the emulated path re-creates the exact bug we just fixed.
                 content = remove_content_after_stop_sequences(content, stop_sequences)
+                content = _close_dangling_code_block(content)
             return ChatMessage(
                 role=role,
                 content=content,
@@ -5650,8 +5894,47 @@ def run_agent_chat(cfg):
                         # for this server, e.g. an MLX-style name against Ollama) —
                         # deterministic, so retrying is pointless. Fail fast with the
                         # server's actual model list so the user can fix Settings.
+                        # A rejected CREDENTIAL is deterministic — retrying re-sends the
+                        # same bad key, and letting it fall through to the turn-level
+                        # handler would degrade to _plain_reply, i.e. the chat model
+                        # answering confidently about work that never ran (#94's failure
+                        # mode). Fail fast with a message that says WHICH key went out:
+                        # python uses `coding_api_key or agent_api_key`, so an unset coding
+                        # key silently authenticates a cloud endpoint with the LOCAL agent
+                        # key (the Auto+cloud path in #117) — a completely different fix
+                        # from "your coding key is wrong". The key itself is never echoed.
+                        if _is_auth_failure(e) or _is_billing_failure(e):
+                            _host = _host_of(coding_base_url)
+                            if _is_billing_failure(e):
+                                raise _AgentConfigError(
+                                    f"The agent coding backend ({_host}) accepted the key "
+                                    "but refused the request for BILLING reasons (out of "
+                                    "credit / quota exhausted). Nothing ran. Top up the "
+                                    "account, or point 'Agent coding model' at another "
+                                    "backend in Settings → Agent."
+                                ) from e
+                            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)."
+                                ) 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. Set 'Coding backend' to OpenAI-compatible "
+                                "in Settings → Agent and enter the API key — the key field "
+                                "only appears once that backend is selected."
+                            ) from e
                         if "404" in emsg and "not found" in emsg.lower():
-                            ids = _list_model_ids(coding_base_url, agent_api_key)
+                            # Probe with the CODING key when there is one: using the agent
+                            # key here 401s against a cloud coder, so the "This server has:
+                            # …" hint — the only useful part of this error — silently
+                            # vanished exactly when it was needed.
+                            ids = _list_model_ids(coding_base_url,
+                                                  coding_api_key or agent_api_key)
                             have = f" This server has: {', '.join(ids)}." if ids else ""
                             raise _AgentConfigError(
                                 f"The agent coding model {coding_model_id!r} does not "
@@ -6094,25 +6377,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,
@@ -6125,9 +6399,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.328",
+  "version": "1.0.332",
   "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",
@@ -17,6 +17,7 @@
     "gonext": "./gonext-repl.mjs"
   },
   "scripts": {
+    "test": "python3 -m unittest discover tests -v",
     "deploy:local": "npm install -g .",
     "run": "gonext-local-worker",
     "publish:org": "npm publish --access public"