@tiens.nguyen/gonext-local-worker 1.0.301 → 1.0.303

package/gonext-local-worker.mjs

@@ -1905,6 +1905,9 @@ async function runAgentChatJob(job) {
       agentModelId: payload?.agentModelId ?? "",
       codingBaseURL: payload?.codingBaseURL ?? "",
       codingModelId: payload?.codingModelId ?? "",
+      // 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,
       // Dedicated SEARCH model (#105): when set, web_search synthesizes its results into a
       // cited answer with this model instead of returning raw read pages. Empty = no synth.
       searchBaseURL: payload?.searchBaseURL ?? "",
@@ -2170,6 +2173,20 @@ async function runAgentChatJob(job) {
             }),
           }).catch(() => {});
         }
+      } else if (event.type === "code_response" && typeof event.text === "string") {
+        // Task #107: the user's Save-Full-Response toggle is on — persist this code-model
+        // response's full raw text to Mongo. Fire-and-forget; never blocks the turn.
+        workerFetch(`/api/worker/agent-response`, {
+          method: "POST",
+          body: JSON.stringify({
+            jobId,
+            step: Number.isFinite(event.step) ? event.step : 0,
+            text: event.text,
+            inputTokens: Number.isFinite(event.inputTokens) ? event.inputTokens : 0,
+            outputTokens: Number.isFinite(event.outputTokens) ? event.outputTokens : 0,
+            codingUrl: payload?.codingBaseURL ?? "",
+          }),
+        }).catch(() => {});
       } else if (event.type === "final" && typeof event.text === "string") {
         closeStreamFence();
         if (inThink) {

package/gonext-repl.mjs

@@ -1383,11 +1383,15 @@ async function runAgentTurn(history) {
     // > the "almost done" heartbeat > the bare fallback.
     const max = Math.max(24, (process.stdout.columns || 80) - 14);
     const fit = (s) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
+    // Task #104: global (user + coding-URL) OUTPUT-token total, ↓ = generated. Add THIS
+    // turn's in-progress output (latestOutputTokens) to the persisted global so the live
+    // count climbs in real time and matches the web; it's reset to 0 once the turn's total
+    // is POSTed into globalOutputTokens (so it's never double-counted).
+    const liveOutputTotal = globalOutputTokens + latestOutputTokens;
     const tokLabel =
       dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
       orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`) +
-      // Task #104: global (user + coding-URL) lifetime OUTPUT-token total, ↓ = generated.
-      (globalOutputTokens > 0 ? cyan(` · ↓ ${fmtTokens(globalOutputTokens)}`) : "");
+      (liveOutputTotal > 0 ? cyan(` · ↓ ${fmtTokens(liveOutputTotal)}`) : "");
     // Task #96: the thought line is "clickable" only when the fuller thought has MORE text than
     // fits on line 1 (a live command / bare "Thinking" / a thought that already fits has nothing
     // to reveal). Line 1 (what's happening now): a live command > the model's current Thought >
@@ -1765,6 +1769,9 @@ async function runAgentTurn(history) {
           outputTokensPosted = true;
           void addOutputTokens(resolve(process.cwd()), latestOutputTokens).then((t) => {
             if (t && Number.isFinite(t.globalTotal)) globalOutputTokens = t.globalTotal;
+            // This turn's total is now folded into globalOutputTokens — zero the live
+            // per-turn tally so the ↓ (global + latest) doesn't double-count it.
+            latestOutputTokens = 0;
           });
         }
         // The job can flip to "completed" between polls with authoritative resultText that
@@ -1802,7 +1809,14 @@ async function runAgentTurn(history) {
           }
         }
         clearStatus();
-        return { text: answerFrom(text), shown: answerShownLive };
+        // Task #104: expose this turn's code-model INPUT + OUTPUT token totals so the caller
+        // can print a persistent footer at the bottom of the screen.
+        return {
+          text: answerFrom(text),
+          shown: answerShownLive,
+          inputTokens: latestCodeTokens,
+          outputTokens: latestOutputTokens,
+        };
       }
       if (text.length > shownChars) {
         if (seenRaw.length < 4096) {
@@ -2112,7 +2126,8 @@ async function main() {
     }
     history.push({ role: "user", content: taskLine });
     try {
-      const { text: answer, shown, cancelled } = await runAgentTurn(history);
+      const { text: answer, shown, cancelled, inputTokens, outputTokens } =
+        await runAgentTurn(history);
       if (answer) {
         history.push({ role: "assistant", content: answer });
         // Persist after every successful turn (not just on clean exit) — an ungraceful
@@ -2122,6 +2137,16 @@ async function main() {
         // A plain-reply answer already streamed live in the loop above — printing it
         // again here would just duplicate it; a blank line is enough for spacing.
         console.log(shown ? "" : `\n\n${answer}\n`);
+        // Task #104: persistent per-turn token footer at the bottom of the screen — the
+        // last turn's code-model INPUT + OUTPUT tokens, kept visible above the next prompt.
+        // Only for turns that actually used the code model (plain-reply greetings = 0/0).
+        if ((inputTokens ?? 0) > 0 || (outputTokens ?? 0) > 0) {
+          console.log(
+            dim("  tokens ·  in ") +
+              fmtTokens(inputTokens ?? 0) +
+              cyan(`  ·  ↓ out ${fmtTokens(outputTokens ?? 0)}`)
+          );
+        }
       } else {
         history.pop(); // aborted/failed/cancelled turn — don't poison the next request
         // A turn that ended WITHOUT an answer (Ctrl+C cancel, or an abort/failure) must not

package/gonext_agent_chat.py

@@ -3117,6 +3117,8 @@ 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 #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:
         same_server = raw_coding_base.rstrip("/") == (agent_base_url or "").rstrip("/")
         if same_server and not raw_coding_model:
@@ -4878,7 +4880,7 @@ def run_agent_chat(cfg):
     # and any step memory it accumulates. completion_kwargs["messages"] here is the
     # literal messages array sent to /v1/chat/completions.
     class _LoggingModel(OpenAIServerModel):
-        def __init__(self, *a, stream_agent=False, **kw):
+        def __init__(self, *a, stream_agent=False, save_full_response=False, **kw):
             # Running total of PROMPT (input) tokens sent to the CODE model across the
             # turn (task #83). Only this wrapper counts — the chat/brain helper calls
             # (_chat_completion) don't route through here, so this is "code model only".
@@ -4904,6 +4906,10 @@ def run_agent_chat(cfg):
             # idle timer never fires. smolagents still receives the COMPLETE text, so its
             # <code>/final_answer parsing is unaffected.
             self._stream_agent = bool(stream_agent)
+            # Task #107: persist each code-model response's full text (opt-in) + a 1-based
+            # per-turn call counter used as the stored `step`.
+            self._save_full_response = bool(save_full_response)
+            self._call_index = 0
             super().__init__(*a, **kw)
 
         def _generate_once(self, *args, **kwargs):
@@ -5246,6 +5252,24 @@ def run_agent_chat(cfg):
                     })
             except Exception:  # noqa: BLE001
                 pass
+            # Task #107: persist the full RAW code-model response (opt-in) with this call's
+            # token counts, emitted BEFORE any think-stripping/normalization so it matches
+            # exactly what the token counts were computed from. Worker forwards to Mongo.
+            if self._save_full_response:
+                try:
+                    self._call_index += 1
+                    _raw = getattr(msg, "content", None)
+                    _tu2 = getattr(msg, "token_usage", None)
+                    _emit({
+                        "type": "code_response",
+                        "step": self._call_index,
+                        "text": _raw if isinstance(_raw, str)
+                        else ("" if _raw is None else str(_raw)),
+                        "inputTokens": int(getattr(_tu2, "input_tokens", 0) or 0) if _tu2 else 0,
+                        "outputTokens": int(getattr(_tu2, "output_tokens", 0) or 0) if _tu2 else 0,
+                    })
+                except Exception:  # noqa: BLE001
+                    pass
             try:
                 content = getattr(msg, "content", None)
                 if content is None:
@@ -5515,6 +5539,8 @@ def run_agent_chat(cfg):
             # 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 #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
             # 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.301",
+  "version": "1.0.303",
   "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",