@tiens.nguyen/gonext-local-worker 1.0.293 → 1.0.295

package/gonext-local-worker.mjs

@@ -1997,6 +1997,10 @@ async function runAgentChatJob(job) {
     let latestCodeTokens = 0;
     // Task #84: peak single-request prompt-token count seen this turn (not the sum).
     let latestMaxCodeTokens = 0;
+    // Task #104: running total of OUTPUT (completion) tokens the CODE model generated this
+    // turn. Persisted to the job doc; the REPL folds this turn's total into the lifetime
+    // per-workspace + per-(user, coding-URL) counters at completion.
+    let latestCodeOutputTokens = 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
@@ -2133,14 +2137,24 @@ async function runAgentChatJob(job) {
         const nextMax = Number.isFinite(event.codeMax)
           ? Math.max(latestMaxCodeTokens, event.codeMax)
           : latestMaxCodeTokens;
-        if (nextTotal !== latestCodeTokens || nextMax !== latestMaxCodeTokens) {
+        // Task #104: output tokens climb monotonically across the turn too.
+        const nextOut = Number.isFinite(event.codeOutput)
+          ? Math.max(latestCodeOutputTokens, event.codeOutput)
+          : latestCodeOutputTokens;
+        if (
+          nextTotal !== latestCodeTokens ||
+          nextMax !== latestMaxCodeTokens ||
+          nextOut !== latestCodeOutputTokens
+        ) {
           latestCodeTokens = nextTotal;
           latestMaxCodeTokens = nextMax;
+          latestCodeOutputTokens = nextOut;
           workerFetch(`/api/worker/jobs/${jobId}`, {
             method: "PATCH",
             body: JSON.stringify({
               agentCodeTokens: latestCodeTokens,
               agentMaxCodeTokens: latestMaxCodeTokens,
+              agentOutputTokens: latestCodeOutputTokens,
             }),
           }).catch(() => {});
         }
@@ -2196,6 +2210,7 @@ async function runAgentChatJob(job) {
         tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
         ...(latestCodeTokens > 0 ? { agentCodeTokens: latestCodeTokens } : {}),
         ...(latestMaxCodeTokens > 0 ? { agentMaxCodeTokens: latestMaxCodeTokens } : {}),
+        ...(latestCodeOutputTokens > 0 ? { agentOutputTokens: latestCodeOutputTokens } : {}),
         totalTimeSeconds,
       }),
     });

package/gonext-repl.mjs

@@ -193,6 +193,8 @@ const COMMANDS = [
   { name: "/server", desc: "pick a deployment server (host/user) for this session" },
   { name: "/revert", usage: "/revert [runId]", desc: "undo the agent's file edits (latest run)" },
   { name: "/reset", aliases: ["/new"], desc: "forget this folder's saved conversation and start fresh" },
+  { name: "/output-token", desc: "show the agent code-model OUTPUT-token total for this workspace" },
+  { name: "/reset-output-token-global", desc: "reset the GLOBAL (you + coding server) output-token total to 0" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -548,6 +550,49 @@ let wsSync = { enabled: false, name: "", path: "" };
 const workspaceKeyFor = (cwd) =>
   createHash("sha256").update(cwd).digest("hex").slice(0, 32);
 
+// Task #104: agent CODE-model OUTPUT-token counters. The API keys the global total on
+// (userId + coding-model URL from settings) and the workspace total on workspaceKey; the
+// REPL just supplies workspaceKey + this turn's delta. All best-effort (never block a turn).
+async function fetchOutputTokenTotals(cwd) {
+  try {
+    const r = await fetch(
+      `${apiBase}/api/worker/output-tokens?workspaceKey=${workspaceKeyFor(cwd)}`,
+      { headers: { "X-Worker-Key": workerKey } }
+    );
+    if (!r.ok) return null;
+    return await r.json();
+  } catch {
+    return null;
+  }
+}
+
+async function addOutputTokens(cwd, delta) {
+  if (!(delta > 0)) return null;
+  try {
+    const r = await fetch(`${apiBase}/api/worker/output-tokens`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+      body: JSON.stringify({ workspaceKey: workspaceKeyFor(cwd), delta }),
+    });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch {
+    return null;
+  }
+}
+
+async function resetGlobalOutputTokens() {
+  try {
+    const r = await fetch(`${apiBase}/api/worker/output-tokens/reset-global`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+    });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
 async function pushWorkspaceSync(cwd, history, { del = false } = {}) {
   if (!wsSync.enabled) return;
   const body = del
@@ -1023,6 +1068,10 @@ let selectedServer = null;
 // 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;
+// Task #104: GLOBAL lifetime OUTPUT-token total for (this user + the agent coding-model
+// API URL), fetched from the API. Shown with a ↓ next to the input/max counts. Updated
+// after each turn (the API returns the new total) and refreshed at startup.
+let globalOutputTokens = 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.
@@ -1235,6 +1284,10 @@ async function runAgentTurn(history) {
   // Running total of prompt tokens sent to the agent CODE model this turn (task #83),
   // read from the job doc each poll. Rendered on the thinking line after the playful word.
   let latestCodeTokens = 0;
+  // Task #104: this turn's OUTPUT-token total, read from the job doc each poll. Folded into
+  // the lifetime per-workspace + global counters once the turn completes.
+  let latestOutputTokens = 0;
+  let outputTokensPosted = false; // guard: increment the lifetime counters once per turn
   // First few KB of the raw stream as consumed — a cheap fingerprint to verify the
   // completed resultText really EXTENDS what we streamed (an old worker replaces it
   // with the shorter bare answer, which must not be sliced by shownChars).
@@ -1321,7 +1374,9 @@ async function runAgentTurn(history) {
     const fit = (s) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
     const tokLabel =
       dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
-      orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`);
+      orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`) +
+      // Task #104: global (user + coding-URL) lifetime OUTPUT-token total, ↓ = generated.
+      (globalOutputTokens > 0 ? cyan(` · ↓ ${fmtTokens(globalOutputTokens)}`) : "");
     // 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 >
@@ -1686,8 +1741,21 @@ async function runAgentTurn(history) {
       if (Number.isFinite(job.agentMaxCodeTokens) && job.agentMaxCodeTokens > sessionMaxCodeTokens) {
         sessionMaxCodeTokens = job.agentMaxCodeTokens;
       }
+      // This turn's OUTPUT-token total (task #104), monotonic across polls.
+      if (Number.isFinite(job.agentOutputTokens) && job.agentOutputTokens > latestOutputTokens) {
+        latestOutputTokens = job.agentOutputTokens;
+      }
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
+        // Task #104: fold this turn's output-token total into the lifetime per-workspace +
+        // global (user + coding-URL) counters, exactly once. Best-effort; the API returns
+        // the new global total, which drives the ↓ header indicator.
+        if (latestOutputTokens > 0 && !outputTokensPosted) {
+          outputTokensPosted = true;
+          void addOutputTokens(resolve(process.cwd()), latestOutputTokens).then((t) => {
+            if (t && Number.isFinite(t.globalTotal)) globalOutputTokens = t.globalTotal;
+          });
+        }
         // 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
@@ -1810,6 +1878,11 @@ async function main() {
   selectedServer = await loadSessionServer(resolve(process.cwd()));
   sessionMaxCodeTokens = await loadSessionMaxCodeTokens(resolve(process.cwd()));
   sessionRagMode = await loadSessionRagMode(resolve(process.cwd())); // task #97: local/cloud/null
+  // Task #104: seed the ↓ global OUTPUT-token total (user + coding-URL) from the API.
+  {
+    const t = await fetchOutputTokenTotals(resolve(process.cwd()));
+    if (t && Number.isFinite(t.globalTotal)) globalOutputTokens = t.globalTotal;
+  }
   // Show which models will answer, straight from user settings (also validates auth).
   try {
     const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);
@@ -1957,6 +2030,40 @@ async function main() {
       console.log(dim("Session cleared — starting fresh.\n"));
       continue;
     }
+    if (line === "/output-token") {
+      // Task #104: print the OUTPUT-token total for THIS workspace (and the global one).
+      const t = await fetchOutputTokenTotals(cwd);
+      if (t && Number.isFinite(t.globalTotal)) globalOutputTokens = t.globalTotal;
+      const ws = t && Number.isFinite(t.workspaceTotal) ? t.workspaceTotal : 0;
+      const gl = t && Number.isFinite(t.globalTotal) ? t.globalTotal : globalOutputTokens;
+      console.log(
+        cyan(`↓ output tokens`) +
+          dim(` — this workspace: `) +
+          `${fmtTokens(ws)}` +
+          dim(`  ·  global (you + coding server): `) +
+          `${fmtTokens(gl)}\n`
+      );
+      continue;
+    }
+    if (line === "/reset-output-token-global") {
+      // Task #104: zero the GLOBAL (user + coding-URL) output-token counter after confirm.
+      const ok = await askYesNo(
+        `Reset the GLOBAL output-token total (currently ${fmtTokens(globalOutputTokens)}) to 0?`,
+        false
+      );
+      if (!ok) {
+        console.log(dim("Cancelled — global output-token total unchanged.\n"));
+        continue;
+      }
+      const done = await resetGlobalOutputTokens();
+      if (done) {
+        globalOutputTokens = 0;
+        console.log(green("✓ global output-token total reset to 0.\n"));
+      } else {
+        console.log(dim("Could not reset the global output-token total (API error).\n"));
+      }
+      continue;
+    }
     if (line.startsWith("/revert")) {
       const runId = line.split(/\s+/)[1] ?? "";
       await new Promise((res) => {

package/gonext_agent_chat.py

@@ -4886,6 +4886,10 @@ def run_agent_chat(cfg):
             # 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
+            # Running total of OUTPUT (completion) tokens the CODE model GENERATED across
+            # the turn (task #104). Reported by the server usage; the REPL adds this turn's
+            # total into the per-workspace + per-(user, coding-URL) global lifetime counters.
+            self._code_output_tokens_total = 0
             # Loop-breaker (#95 B1): how many CONSECUTIVE generations have produced a code
             # block that STILL won't compile after our repair. A weak coder can get stuck
             # re-emitting the same unparseable tool call (seen live: create_file with a
@@ -5225,6 +5229,23 @@ def run_agent_chat(cfg):
                     })
             except Exception:  # noqa: BLE001
                 pass
+            # Task #104: accumulate OUTPUT (completion) tokens this step and report the
+            # running total. Unlike input, there's no request-time estimate — output is
+            # only known once the model finished, so we emit after the call returns.
+            try:
+                tu = getattr(msg, "token_usage", None)
+                step_out = int(getattr(tu, "output_tokens", 0) or 0) if tu else 0
+                if step_out > 0:
+                    self._code_output_tokens_total += step_out
+                    _emit({
+                        "type": "tokens",
+                        "codeInput": self._code_tokens_total,
+                        "codeMax": self._code_tokens_max,
+                        "codeOutput": self._code_output_tokens_total,
+                        "stepOutput": step_out,
+                    })
+            except Exception:  # noqa: BLE001
+                pass
             try:
                 content = getattr(msg, "content", None)
                 if content is None:

package/package.json

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