@tiens.nguyen/gu-cli 1.0.783 → 1.0.785

package/completed-flush.mjs

@@ -103,3 +103,50 @@ export function completedFlush({
   const steps = tail.slice(0, close);
   return steps ? { kind: "steps", text: steps } : { kind: "none", text: "" };
 }
+
+/**
+ * WHILE THE JOB IS STILL RUNNING: which of the newly arrived text is the turn's WORK (step lines
+ * and thoughts, inside <think>…</think>) and which is the ANSWER (outside it). Task #326.
+ *
+ * An agent turn's stream is `<think>steps…</think>answer`. The answer is the caller's to print —
+ * once, wrapped, from the completed resultText. completedFlush has always stopped at </think> for
+ * that reason, but the RUNNING poll did not: it fed everything to the step printer. So whenever
+ * the answer's chunk was polled before the job flipped to "completed" (any answer long enough to
+ * be posted on its own), every paragraph of it was printed as a "●" step bullet — and then the
+ * whole answer again under "recap:". Reported as the answer appearing twice; short answers escaped
+ * only because their chunk and the completion arrived in the same poll.
+ *
+ * `state` is carried from poll to poll: { inThink, held }. `held` is the start of a tag cut in two
+ * by a poll boundary ("</thi" + "nk>"), kept back until the rest arrives.
+ * → { parts: [{ inside, text }], state } — the tags themselves are dropped.
+ */
+export function splitLiveStream(fresh, state = {}) {
+  let text = String(state.held ?? "") + String(fresh ?? "");
+  let inThink = Boolean(state.inThink);
+  const parts = [];
+  const push = (inside, t) => {
+    if (!t) return;
+    const last = parts[parts.length - 1];
+    if (last && last.inside === inside) last.text += t;
+    else parts.push({ inside, text: t });
+  };
+  // Hold back a tail that could be the beginning of a tag.
+  let held = "";
+  const lt = text.lastIndexOf("<");
+  if (lt >= 0 && lt > text.length - 8) {
+    const tail = text.slice(lt).toLowerCase();
+    if ("<think>".startsWith(tail) || "</think>".startsWith(tail)) {
+      held = text.slice(lt);
+      text = text.slice(0, lt);
+    }
+  }
+  const re = /<(\/?)think>/gi;
+  let at = 0;
+  for (let m; (m = re.exec(text)); ) {
+    push(inThink, text.slice(at, m.index));
+    inThink = m[1] !== "/";
+    at = m.index + m[0].length;
+  }
+  push(inThink, text.slice(at));
+  return { parts, state: { inThink, held } };
+}

package/gonext_agent_chat.py

@@ -7782,7 +7782,7 @@ def run_agent_chat(cfg):
     _skill_call = _skills_mod.invocation(task_text, _skills)
     if _skill_call:
         _sk, _sk_body, _sk_req = _skill_call
-        task_text = (_skills_mod.render(_sk, _sk_body) + "\n\nThe user's request: "
+        task_text = (_skills_mod.render(_sk, _sk_body, _sk_req) + "\n\nThe user's request: "
                      + (_sk_req or "(nothing more — do what the skill describes)"))
         _log(f"skill invoked: {_sk['name']}")
 

package/gu-cli.mjs

@@ -20,7 +20,7 @@ import { execFile as execFileCallback, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { writeFileSync, unlinkSync } from "node:fs";
 import { createTaskPool, createFolderQueue } from "./job-pools.mjs";
-import { NO_STEP, foldStepTokens, withStepTokens } from "./step-tokens.mjs";
+import { NO_STEP, foldStepTokens, withStepTokens, NO_CACHE, foldTurnCache, withTurnCache } from "./step-tokens.mjs";
 import { agentStoppedLine, jobEnded, jobStatusFrom409, stopGracefully } from "./agent-stop.mjs";
 import { ragJobConfig } from "./rag-job-config.mjs";
 import { codingKeyFallbackLine, isOllamaCloudUrl } from "./coding-key-prompt.mjs";
@@ -4138,6 +4138,9 @@ async function runAgentChatJob(job) {
     // Task #298: the CURRENT model call's own ↑ in / ↓ out, for the thinking line (the bar
     // already shows the totals). Rides on the breakdown — see step-tokens.mjs.
     let stepTokens = NO_STEP;
+    // #323: the turn's cached prompt tokens (when the provider reports them) and its first step's
+    // prompt — what the terminal needs to say what the turn COST. Rides on the breakdown too.
+    let turnCache = NO_CACHE;
     // 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
@@ -4305,17 +4308,20 @@ async function runAgentChatJob(job) {
         if (breakdown) latestPromptBreakdown = breakdown;
         const prevStep = stepTokens;
         stepTokens = foldStepTokens(stepTokens, event);
+        const prevCache = turnCache;
+        turnCache = foldTurnCache(turnCache, event);
+        const cacheChanged = turnCache.cached !== prevCache.cached || turnCache.firstIn !== prevCache.firstIn || turnCache.cacheReported !== prevCache.cacheReported;
         const stepChanged =
           stepTokens.step !== prevStep.step ||
           stepTokens.stepIn !== prevStep.stepIn ||
           stepTokens.stepOut !== prevStep.stepOut;
-        if (latestPromptBreakdown) latestPromptBreakdown = withStepTokens(latestPromptBreakdown, stepTokens);
+        if (latestPromptBreakdown) latestPromptBreakdown = withTurnCache(withStepTokens(latestPromptBreakdown, stepTokens), turnCache);
         if (
           nextTotal !== latestCodeTokens ||
           nextMax !== latestMaxCodeTokens ||
           nextOut !== latestCodeOutputTokens ||
           breakdown ||
-          (stepChanged && latestPromptBreakdown)
+          ((stepChanged || cacheChanged) && latestPromptBreakdown)
         ) {
           latestCodeTokens = nextTotal;
           latestMaxCodeTokens = nextMax;