@tiens.nguyen/gonext-local-worker 1.0.216 → 1.0.219

package/gonext-local-worker.mjs

@@ -1229,11 +1229,44 @@ function normalizeCorrection(raw, originalText) {
  * correction/translation, e.g. base "https://ollama1.gomarsic.cc" model "qwen3:14b".
  * `think:false` suppresses reasoning models' <think> preamble so we get clean text.
  */
+const OCR_CORRECT_SYSTEM_PROMPT =
+  "You are a text correction assistant. Fix grammar and language errors in the " +
+  "provided text while preserving the original meaning and language. " +
+  "Return only the corrected text without any explanation.";
+
+/**
+ * Call an OpenAI-compatible chat endpoint (POST {base}/v1/chat/completions) for text
+ * correction — e.g. an MLX `mlx_lm.server` (the agent model server) at
+ * http://127.0.0.1:8080/v1 serving qwen3:14b. Strips any <think> preamble.
+ */
+async function correctOcrTextViaOpenAI(extractedText, base, model) {
+  const b = base.replace(/\/+$/, "");
+  const url = /\/v1$/.test(b) ? `${b}/chat/completions` : `${b}/v1/chat/completions`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      stream: false,
+      temperature: 0,
+      messages: [
+        { role: "system", content: OCR_CORRECT_SYSTEM_PROMPT },
+        { role: "user", content: `Text:\n${extractedText}` },
+      ],
+    }),
+    signal: AbortSignal.timeout(OCR_CORRECT_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new Error(`MLX ${b} returned ${res.status}`);
+  }
+  const json = await res.json();
+  let corrected = json?.choices?.[0]?.message?.content?.trim() || "";
+  corrected = corrected.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+  return normalizeCorrection(corrected, extractedText);
+}
+
 async function correctOcrTextViaOllama(extractedText, base, model) {
-  const systemPrompt =
-    "You are a text correction assistant. Fix grammar and language errors in the " +
-    "provided text while preserving the original meaning and language. " +
-    "Return only the corrected text without any explanation.";
+  const systemPrompt = OCR_CORRECT_SYSTEM_PROMPT;
   const res = await fetch(`${base.replace(/\/+$/, "")}/api/chat`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -1260,24 +1293,27 @@ async function correctOcrTextViaOllama(extractedText, base, model) {
   return normalizeCorrection(corrected, extractedText);
 }
 
-async function correctOcrText(extractedText) {
+async function correctOcrText(extractedText, correction) {
   if (OCR_SKIP_CORRECTION) {
     console.log("[gonext-worker] OCR correction skipped (GONEXT_OCR_SKIP_CORRECTION=1)");
     return extractedText;
   }
 
-  // OCR translation/correction is hardcoded to a managed Ollama service + model
-  // (the user-configurable chooser was removed). Any error falls back to raw text.
+  // The API resolves the backend from the user's settings and bakes {backend,url,model}
+  // into the job payload — DEFAULT is "mlx" (the agent MLX model server, OpenAI /v1).
+  // Absent (older jobs / no settings) → fall back to the legacy managed-Ollama default.
+  const backend = correction?.backend === "mlx" ? "mlx" : "ollama";
+  const url = (correction?.url || "").trim() || OCR_TRANSLATE_OLLAMA_URL;
+  const model = (correction?.model || "").trim() || OCR_TRANSLATE_OLLAMA_MODEL;
   console.log(
-    `[gonext-worker] OCR correction via Ollama ${OCR_TRANSLATE_OLLAMA_URL} model=${OCR_TRANSLATE_OLLAMA_MODEL}`
+    `[gonext-worker] OCR correction via ${backend} ${url} model=${model}`
   );
   console.log(`[gonext-worker] OCR correction input: ${extractedText.slice(0, 300)}`);
   try {
-    const corrected = await correctOcrTextViaOllama(
-      extractedText,
-      OCR_TRANSLATE_OLLAMA_URL,
-      OCR_TRANSLATE_OLLAMA_MODEL
-    );
+    const corrected =
+      backend === "mlx"
+        ? await correctOcrTextViaOpenAI(extractedText, url, model)
+        : await correctOcrTextViaOllama(extractedText, url, model);
     console.log(`[gonext-worker] OCR correction output: ${corrected.slice(0, 300)}`);
     console.log(
       `[gonext-worker] OCR correction done: ${extractedText.length} → ${corrected.length} chars`
@@ -1286,7 +1322,7 @@ async function correctOcrText(extractedText) {
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     console.warn(
-      `[gonext-worker] OCR correction Ollama failed (using raw OCR text): ${msg.slice(0, 200)}`
+      `[gonext-worker] OCR correction (${backend}) failed (using raw OCR text): ${msg.slice(0, 200)}`
     );
     return extractedText;
   }
@@ -1434,10 +1470,10 @@ async function runOcrJob(job) {
     } finally {
       await rm(tempDir, { recursive: true, force: true }).catch(() => {});
     }
-    // Post-process: correct grammar/language via the hardcoded managed Ollama
-    // service (qwen3:14b). Falls back to raw OCR text on any error so the job
-    // never fails here. (`payload.correctionModel` is no longer used.)
-    extractedText = await correctOcrText(extractedText);
+    // Post-process: correct grammar/language via the backend the API resolved from the
+    // user's settings (payload.correction = {backend,url,model}; default MLX = the agent
+    // model server). Falls back to raw OCR text on any error so the job never fails here.
+    extractedText = await correctOcrText(extractedText, payload.correction);
     const totalTimeSeconds = (Date.now() - start) / 1000;
     const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
       method: "PATCH",

package/gonext-repl.mjs

@@ -965,9 +965,19 @@ async function runAgentTurn(history) {
       jobRunning = job.jobStatus === "running";
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
-        // Drop the transient status line and any partial reasoning tail. If this was a
-        // plain reply, its text is ALREADY fully visible (streamed live above) — the
-        // caller must not print it again; `shown` tells it so.
+        // The job can flip to "completed" between polls with authoritative resultText that
+        // the live stream hasn't caught up to yet (a debounced last chunk, or the final
+        // PATCH landing before its chunk flush was polled). resultText is the source of
+        // truth, so flush any not-yet-shown suffix BEFORE returning — otherwise a plain
+        // reply, whose live stream is its ONLY output, renders truncated mid-word. Gated
+        // to plainReplyFlow: the agent path reprints its answer from resultText via the
+        // caller (shown=false), so a live flush there is unnecessary (and would compound
+        // the separate agent double-print). This runs for the completed poll only; the
+        // running-branch consume below handles every earlier poll.
+        if (plainReplyFlow && text.length > shownChars) {
+          consume(text.slice(shownChars));
+          shownChars = text.length;
+        }
         clearStatus();
         return { text: answerFrom(text), shown: answerShownLive };
       }

package/package.json

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