@tiens.nguyen/gonext-local-worker 1.0.309 → 1.0.311

package/gonext-local-worker.mjs

@@ -1803,8 +1803,12 @@ async function runAgentChatJob(job) {
   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.
-  trackCodingModelForWarmup(payload?.codingBaseURL ?? "", payload?.codingModelId ?? "");
+  // 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 ?? "");
+  }
   const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
     method: "PATCH",
     body: JSON.stringify({ jobStatus: "running" }),
@@ -1898,6 +1902,25 @@ 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
+      : "";
+    let codingApiKey = "";
+    if (codingKind === "openai") {
+      try {
+        const kr = await workerFetch("/api/worker/coding-key");
+        if (kr.ok) {
+          const kj = await kr.json().catch(() => ({}));
+          if (typeof kj?.apiKey === "string") codingApiKey = kj.apiKey;
+        }
+      } catch {
+        /* best-effort — python falls back to a keyless call, which the endpoint may 401 */
+      }
+    }
+
     const input = JSON.stringify({
       messages: payload?.messages ?? [],
       agentBaseURL: payload?.agentBaseURL ?? "",
@@ -1905,6 +1928,8 @@ async function runAgentChatJob(job) {
       agentModelId: payload?.agentModelId ?? "",
       codingBaseURL: payload?.codingBaseURL ?? "",
       codingModelId: payload?.codingModelId ?? "",
+      codingKind,
+      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.
       saveFullResponse: payload?.saveFullResponse === true,

package/gonext-repl.mjs

@@ -1113,6 +1113,63 @@ function pickFromList(items, initialSel = 0, opts = {}) {
   });
 }
 
+// Cancel whichever approval picker is currently showing (Yes/No or the N-row list),
+// resolving it as a DENY. Used when the job ends server-side while we're still waiting
+// for the user, so the picker promise never leaks and no late choice is sent (#110).
+function cancelActivePicker() {
+  if (approvalActive) finishApproval(false);
+  if (listPickerActive) finishList(-1);
+}
+
+// Show an approval picker, but RACE it against the job going terminal. The old code
+// awaited the picker INLINE inside the poll loop, so while the user thought, the REPL
+// stopped polling and couldn't notice that python had already given up (its own approval
+// deadline) and completed the job — the user's late "Yes" then hit a finished job and was
+// silently lost (#110). Here a background watcher polls the job; if it goes
+// completed/failed/cancelled first, we dismiss the picker and report `ended:true` so the
+// caller skips the POST and lets the normal terminal-status handling run.
+async function approvalPromptRacingJob(command) {
+  let watching = true;
+  const watcher = (async () => {
+    while (watching) {
+      await sleep(1000);
+      if (!watching) return null;
+      try {
+        const r = await fetch(`${apiBase}/api/worker/jobs/${jobIdForApprovalRace}`, {
+          headers: { "X-Worker-Key": workerKey },
+        });
+        if (!r.ok) continue;
+        const j = await r.json().catch(() => ({}));
+        if (
+          j?.jobStatus === "completed" ||
+          j?.jobStatus === "failed" ||
+          j?.jobStatus === "cancelled"
+        ) {
+          return "ended";
+        }
+      } catch {
+        /* transient poll error — keep watching */
+      }
+    }
+    return null;
+  })();
+  const picker = approvalPrompt(command).then((r) => ({ kind: "answer", ...r }));
+  const raced = await Promise.race([
+    picker,
+    watcher.then((v) => (v === "ended" ? { kind: "ended" } : new Promise(() => {}))),
+  ]);
+  watching = false;
+  if (raced.kind === "ended") {
+    cancelActivePicker(); // unblock the picker promise so it doesn't leak
+    await picker.catch(() => {}); // let it settle after the cancel
+    return { ended: true, allow: false, dontAsk: false };
+  }
+  // The user answered first — stop the watcher and return their choice.
+  return { ended: false, allow: raced.allow, dontAsk: raced.dontAsk };
+}
+// The jobId the approval race should watch — set by runAgentTurn before it can prompt.
+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.
 let sessionCodingModel = "";
@@ -1326,6 +1383,7 @@ async function runAgentTurn(history) {
   following = true;
   followAborted = false;
   currentJobId = jobId;
+  jobIdForApprovalRace = jobId; // so an approval picker can watch THIS job for early end (#110)
   cancelRequested = false;
   const startedAt = Date.now();
   let shownChars = 0;
@@ -1894,7 +1952,19 @@ async function runAgentTurn(history) {
       ) {
         lastApprovalId = job.pendingApproval.id;
         clearStatus();
-        const { allow, dontAsk } = await approvalPrompt(job.pendingApproval.command || "");
+        // Race the picker against the job ending server-side (#110): if python gives up
+        // (its own approval deadline) and completes the job while we're waiting, dismiss
+        // the picker and DON'T post a now-useless choice — fall through to the normal
+        // completed/failed/cancelled handling below on the next poll.
+        const { ended, allow, dontAsk } = await approvalPromptRacingJob(
+          job.pendingApproval.command || ""
+        );
+        if (ended) {
+          process.stdout.write(
+            dim("\n  (the run already ended before you chose — reply 'continue' to resume)\n")
+          );
+          continue; // re-poll; the terminal-status branches below take it from here
+        }
         // "Yes, don't ask again this session" (max-step prompt only): remember it so every
         // later turn sends alwaysExtendOnMaxStep and the agent auto-extends silently (#80).
         if (dontAsk) {

package/gonext_agent_chat.py

@@ -2835,10 +2835,16 @@ def _ws_command_risk(command, argv, denyset):
     return (None, None)
 
 
-def _ws_request_approval(api_base, worker_key, job_id, command, reason):
+def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline_s=180):
     """Pause and ask the user (via the terminal REPL's Yes/No picker) to allow a risky
     command. Registers a pending approval on the job through the API, then polls the job
     for the user's decision. Returns True (allow) or False (deny / timeout / cancelled).
+
+    deadline_s bounds the wait. 180s is right for a RISKY command (absent user → deny,
+    never auto-run). But the __MAXSTEP__ "keep going?" prompt is NOT security-sensitive and
+    the coder can be slow, so it passes a much larger deadline (#110): the REPL now
+    dismisses the picker the instant this job ends, and the worker's own job-cap kills a
+    truly-abandoned run, so a long wait here is safe and lets a real "Yes" actually land.
     Mirrors _pdf_upload_via_api's worker-key auth — no new creds on the worker."""
     import urllib.request as _u
     import uuid as _uuid
@@ -2866,7 +2872,7 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason):
         _emit({"type": "step", "text": "Awaiting your choice: compact the context?"})
     else:
         _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
-    deadline = _t.time() + 180  # 3 min; absent user → deny (never auto-run something risky)
+    deadline = _t.time() + max(30, int(deadline_s))  # per-call; risky=180s, __MAXSTEP__ long
     while _t.time() < deadline:
         _t.sleep(1.2)
         try:
@@ -3117,6 +3123,14 @@ def run_agent_chat(cfg):
     # also fixes an older API layer that appended /v1 after the native /api path).
     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 = (cfg.get("codingKind") or "").strip().lower()
+    if coding_kind not in ("ollama", "openai"):
+        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.
     save_full_response = bool(cfg.get("saveFullResponse"))
     if raw_coding_base:
@@ -3136,7 +3150,8 @@ def run_agent_chat(cfg):
             # A DIFFERENT dedicated coding server. If no model name was given, ask the
             # server which model it serves (mlx_lm.server otherwise tries to download a
             # mismatched name from HF and 404s).
-            detected = raw_coding_model or _detect_model_id(raw_coding_base, agent_api_key)
+            detected = raw_coding_model or _detect_model_id(
+                raw_coding_base, coding_api_key or agent_api_key)
             if detected:
                 coding_base_url = raw_coding_base
                 coding_model_id = detected
@@ -3150,6 +3165,15 @@ def run_agent_chat(cfg):
     else:
         coding_base_url = agent_base_url
         coding_model_id = agent_model_id
+    # Task #108: an OpenAI-compatible coder REQUIRES an explicit model name (its
+    # /v1/chat/completions needs a `model` id, and we won't silently reuse the MLX chat
+    # model's name against a cloud endpoint). Fail with a clear, actionable message.
+    if coding_kind == "openai" and not (raw_coding_model or "").strip():
+        raise _AgentConfigError(
+            "Your agent coding model is set to OpenAI-compatible but has no model name. "
+            "Enter the exact model id your endpoint expects (e.g. gpt-4o-mini) in "
+            "Settings → Agent → Agent coding model name."
+        )
     # Multi-step ReAct loop (thinking agent): the agent may take several
     # Thought → tool → Observation steps and then call final_answer() itself. This
     # replaced the old strict single-shot (max_steps=1) once a stronger coding model
@@ -5528,17 +5552,34 @@ 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 = {}
-        coding_is_ollama = _is_ollama_server(coding_base_url)
+        # 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:
             _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'}")
         model = _LoggingModel(
             model_id=coding_model_id,
             api_base=coding_base_url,
-            api_key=agent_api_key,
-            # Stream for Ollama so a long generation keeps the connection warm and can't
-            # trip a reverse-proxy idle read-timeout. smolagents still gets the full text.
-            stream_agent=coding_is_ollama,
+            # Task #108: use the OpenAI-compatible coding key when set, else the chat key.
+            api_key=coding_api_key or agent_api_key,
+            # Stream for Ollama / OpenAI-compatible so a long generation keeps the connection
+            # warm and can't trip a reverse-proxy idle read-timeout (smolagents still gets the
+            # full text). Only a local MLX coder stays non-streaming.
+            stream_agent=_stream_coder,
             # Task #107: persist each code-model response to Mongo when the user opted in.
             save_full_response=save_full_response,
             # Cap each HTTP attempt at 600s so a genuinely slow single call (a
@@ -6543,10 +6584,14 @@ def run_agent_chat(cfg):
                          "(don't-ask-again session flag)")
                     _do_extend = True
                 elif _interactive_approval and _job_id and pdf_api_base and pdf_worker_key:
+                    # Long deadline (#110): the "keep going?" prompt isn't risky, and the
+                    # slow coder + a thinking user shouldn't get auto-denied at 180s. The
+                    # REPL dismisses the picker if this job ends, and the worker job-cap
+                    # bounds a walked-away user, so waiting here is safe.
                     _do_extend = _ws_request_approval(
                         pdf_api_base, pdf_worker_key, _job_id,
                         f"__MAXSTEP__::Reached the step budget ({agent.max_steps}). "
-                        "Keep going?", "max-steps")
+                        "Keep going?", "max-steps", deadline_s=1500)
                 else:
                     _do_extend = False  # web / no interactive channel → current wrap-up
                 if not _do_extend:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.309",
+  "version": "1.0.311",
   "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",