@tiens.nguyen/gonext-local-worker 1.0.252 → 1.0.253

package/gonext-local-worker.mjs

@@ -1984,6 +1984,8 @@ async function runAgentChatJob(job) {
     // each python "tokens" event, persisted to the job doc (Mongo) so the REPL can show
     // it live and it survives on the completed job.
     let latestCodeTokens = 0;
+    // Task #84: peak single-request prompt-token count seen this turn (not the sum).
+    let latestMaxCodeTokens = 0;
     // Raw model-stream tokens (event.type === "stream") are Python code + `Thought:`
     // prose + <code>/<|"|> fragments. The web Thought panel renders reasoning as
     // markdown, which turns `#`-prefixed code comments into <h1> headings and
@@ -2111,16 +2113,24 @@ async function runAgentChatJob(job) {
         enqueueText(event.text);
         answerStreamed = true;
       } else if (event.type === "tokens" && Number.isFinite(event.codeInput)) {
-        // Prompt tokens sent to the agent CODE model (task #83). Persist the running
-        // total to the job doc so it's in Mongo and the REPL can render it live. Steps
-        // are seconds apart, so a fire-and-forget PATCH per event is cheap; it only
-        // touches agentCodeTokens (never resultText/jobStatus), so it can't race the
-        // chunk/completed writes.
-        if (event.codeInput > latestCodeTokens) {
-          latestCodeTokens = event.codeInput;
+        // Prompt tokens sent to the agent CODE model (tasks #83 accumulated + #84 peak).
+        // Persist both to the job doc so they're in Mongo and the REPL can render them
+        // live. Steps are seconds apart, so a fire-and-forget PATCH per event is cheap;
+        // it only touches agentCodeTokens/agentMaxCodeTokens (never resultText/jobStatus),
+        // so it can't race the chunk/completed writes.
+        const nextTotal = Math.max(latestCodeTokens, event.codeInput);
+        const nextMax = Number.isFinite(event.codeMax)
+          ? Math.max(latestMaxCodeTokens, event.codeMax)
+          : latestMaxCodeTokens;
+        if (nextTotal !== latestCodeTokens || nextMax !== latestMaxCodeTokens) {
+          latestCodeTokens = nextTotal;
+          latestMaxCodeTokens = nextMax;
           workerFetch(`/api/worker/jobs/${jobId}`, {
             method: "PATCH",
-            body: JSON.stringify({ agentCodeTokens: latestCodeTokens }),
+            body: JSON.stringify({
+              agentCodeTokens: latestCodeTokens,
+              agentMaxCodeTokens: latestMaxCodeTokens,
+            }),
           }).catch(() => {});
         }
       } else if (event.type === "final" && typeof event.text === "string") {
@@ -2174,6 +2184,7 @@ async function runAgentChatJob(job) {
         resultText: answerStreamed ? fullText : finalText || fullText,
         tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
         ...(latestCodeTokens > 0 ? { agentCodeTokens: latestCodeTokens } : {}),
+        ...(latestMaxCodeTokens > 0 ? { agentMaxCodeTokens: latestMaxCodeTokens } : {}),
         totalTimeSeconds,
       }),
     });

package/gonext-repl.mjs

@@ -122,6 +122,7 @@ const SPINNERS = [
 // green, cyan, blue, indigo, pink, amber).
 const WAIT_COLORS_256 = [120, 87, 111, 147, 218, 221];
 const color256 = (n, s) => `\x1b[38;5;${n}m${s}\x1b[0m`;
+const orange = (s) => color256(208, s); // peak-token label (task #84)
 // Compact token count: 950 → "950", 12300 → "12.3k", 1500000 → "1.5M" (task #83).
 const fmtTokens = (n) => {
   if (n < 1000) return String(n);
@@ -564,6 +565,16 @@ async function loadSessionServer(cwd) {
   }
 }
 
+// Peak single-request agent-code-model token count remembered per folder (task #84).
+async function loadSessionMaxCodeTokens(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return Number.isFinite(raw?.maxCodeTokens) ? raw.maxCodeTokens : 0;
+  } catch {
+    return 0;
+  }
+}
+
 async function saveSession(cwd, history) {
   try {
     await mkdir(SESSIONS_DIR, { recursive: true });
@@ -576,6 +587,7 @@ async function saveSession(cwd, history) {
           updatedAt: new Date().toISOString(),
           testAuto: sessionTestAuto,
           deployServer: selectedServer, // remember the /server pick per folder (task #69)
+          maxCodeTokens: sessionMaxCodeTokens, // peak per-request tokens (task #84)
           history: trimmed,
         },
         null,
@@ -919,6 +931,10 @@ let alwaysExtendOnMaxStep = false;
 // Deploy target chosen via /server (task #69): {name, host, user} or null. Session-scoped;
 // sent to /agent-ask as deployServer so the agent deploys to this host with KEY auth.
 let selectedServer = null;
+// Task #84: peak single-request agent-code-model token count for THIS workspace, kept
+// as a max across turns and persisted per folder in the session file. Shown in orange
+// next to the live token count.
+let sessionMaxCodeTokens = 0;
 
 // While a turn runs, mute readline's own echo/redraws so keystrokes can't corrupt the
 // live status display and there's no way to type a new question — only Ctrl+C works.
@@ -1148,10 +1164,12 @@ async function runAgentTurn(history) {
     // Line 2 (indented): the SPINNER + the playful word together, both in the cycling
     // color — the spinner belongs with the word (dot on the label line, spinner leading
     // the flavor line).
-    // Task #83: after the playful word, ALWAYS show the running agent-code-model token
-    // count (dim), e.g. "  ⠙ Caffeinating… · 12.3k tok" — starts at "· 0 tok" and climbs
-    // as steps send more, so it's visible from the first thinking frame.
-    const tokLabel = dim(` · ${fmtTokens(latestCodeTokens)} tok`);
+    // Task #83/#84: after the playful word, show the running agent-code-model token
+    // count (dim) plus the per-workspace PEAK single-request count (orange), e.g.
+    // "  ⠙ Caffeinating… · 12.3k tok · 8.1k max". Both start at 0 and climb.
+    const tokLabel =
+      dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
+      orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`);
     process.stdout.write(
       `${green(BULLET)} ${green(`${fit(primary)}… (${secs}s)`)}` +
         "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`
@@ -1424,6 +1442,10 @@ async function runAgentTurn(history) {
       if (Number.isFinite(job.agentCodeTokens) && job.agentCodeTokens > latestCodeTokens) {
         latestCodeTokens = job.agentCodeTokens;
       }
+      // Peak single-request tokens (task #84): keep the per-workspace max across turns.
+      if (Number.isFinite(job.agentMaxCodeTokens) && job.agentMaxCodeTokens > sessionMaxCodeTokens) {
+        sessionMaxCodeTokens = job.agentMaxCodeTokens;
+      }
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
         // The job can flip to "completed" between polls with authoritative resultText that
@@ -1541,6 +1563,7 @@ async function main() {
   // reflect them (both survive a fresh terminal in the same project).
   sessionTestAuto = await loadSessionTestAuto(resolve(process.cwd()));
   selectedServer = await loadSessionServer(resolve(process.cwd()));
+  sessionMaxCodeTokens = await loadSessionMaxCodeTokens(resolve(process.cwd()));
   // Show which models will answer, straight from user settings (also validates auth).
   try {
     const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);

package/gonext_agent_chat.py

@@ -3940,6 +3940,9 @@ def run_agent_chat(cfg):
             # 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".
             self._code_tokens_total = 0
+            # Largest SINGLE-request prompt-token count seen this turn (task #84) — the
+            # peak context size, not the sum. The REPL keeps a per-workspace max of this.
+            self._code_tokens_max = 0
             # stream_agent: request the completion with stream=True and reassemble the
             # deltas into one message. Enabled for Ollama, where a long single-shot
             # (non-stream) generation sends nothing until the very end — a reverse proxy
@@ -4182,6 +4185,19 @@ def run_agent_chat(cfg):
             # _mark_first), read by the heartbeat below to switch its wording.
             self._first_token_seen = False
 
+            # Task #83: emit the PROMPT-token estimate NOW, at request time — so the
+            # code-model token count climbs the instant a step is SENT, not only after a
+            # slow step returns usage (a cold gemma4 can wait minutes for the first token,
+            # during which the count would otherwise sit at 0). We reconcile to the exact
+            # server-reported prompt_tokens after the call when it's higher.
+            _step_est = self._estimate_prompt_tokens(args, kwargs)
+            if _step_est > 0:
+                self._code_tokens_total += _step_est
+                if _step_est > self._code_tokens_max:
+                    self._code_tokens_max = _step_est
+                _emit({"type": "tokens", "codeInput": self._code_tokens_total,
+                       "codeMax": self._code_tokens_max, "stepInput": _step_est})
+
             def _heartbeat():
                 waited = 0
                 while not hb_stop.wait(45):
@@ -4226,20 +4242,21 @@ def run_agent_chat(cfg):
                     raise last_err
             finally:
                 hb_stop.set()
-            # Task #83: tally PROMPT tokens sent to the code model this step, then emit
-            # the running total so the worker can persist it (Mongo) and the REPL can
-            # show it live. Best-effort — never let accounting break the run.
+            # Task #83: reconcile the pre-call estimate with the server's EXACT
+            # prompt_tokens when it's higher — keeps the running total monotonic (the
+            # estimate already showed the count climbing at request time). Best-effort.
             try:
                 tu = getattr(msg, "token_usage", None)
-                step_in = int(getattr(tu, "input_tokens", 0) or 0) if tu else 0
-                if step_in <= 0:
-                    step_in = self._estimate_prompt_tokens(args, kwargs)
-                if step_in > 0:
-                    self._code_tokens_total += step_in
+                exact = int(getattr(tu, "input_tokens", 0) or 0) if tu else 0
+                if exact > _step_est:
+                    self._code_tokens_total += (exact - _step_est)
+                    if exact > self._code_tokens_max:
+                        self._code_tokens_max = exact
                     _emit({
                         "type": "tokens",
                         "codeInput": self._code_tokens_total,
-                        "stepInput": step_in,
+                        "codeMax": self._code_tokens_max,
+                        "stepInput": exact,
                     })
             except Exception:  # noqa: BLE001
                 pass

package/package.json

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