@tiens.nguyen/gu-cli 1.0.823 → 1.0.825

package/gonext_agent_chat.py

@@ -2026,7 +2026,11 @@ def _is_greeting_smalltalk(text: str) -> bool:
 # self-labels as "Thought"/"Thinking Process" up front (a real answer doesn't open by
 # naming itself as the model's own reasoning), or it's dense with self-correction
 # language a finished answer wouldn't contain.
-_SCRATCHPAD_START_RE = re.compile(r"^\s*thought\b\s*[:\n]", re.I)
+# The label may come dressed as markdown — "## Thought" or "**Thought:**" — and is still the
+# model naming its own reasoning (#139: Kimi K3 wrote "## Thought\n\n… Let me check git status"
+# and it was delivered as the ANSWER to "commit", so nothing ran).
+_SCRATCHPAD_START_RE = re.compile(
+    r"^\s*(?:#{1,6}\s*|\*\*|__)?thought(?:\s*:|\s*(?:\*\*|__)\s*:?|\s*\n)", re.I)
 _DELIBERATION_RE = re.compile(
     r"\b(wait,|actually,|let'?s (try|just|use|list|see|go)|"
     r"i (?:need to|should) (?:check|verify|confirm))\b",
@@ -2194,11 +2198,41 @@ def _machine_context(platform_name: str = "", arch: str = "", cwd: str = "") ->
     )
 
 
+# A reply that ENDS by announcing its next action is a plan, not an answer (#139, live: "Two
+# logical changes to commit: 1. … 2. … Let me check what changed in api/latest.json …" was
+# wrapped as the answer to "commit" because its numbered list looked finished). Only the LAST
+# paragraph counts, "let me know" / "I'll be" are not actions, and a step handed to the user
+# ("I'll push when you say so") is a finished answer.
+_NEXT_STEP_RE = re.compile(
+    r"\b(?:let me|let's|let us|i'll|i will|i'm going to|i am going to|i need to|"
+    r"next,? i(?:'ll| will| need to)?|now i(?:'ll| will)?)\s+(?:also\s+|now\s+|first\s+|quickly\s+)?"
+    r"(?:check|look|see|read|run|inspect|verify|review|examine|find|search|grep|open|"
+    r"stage|commit|create|write|edit|fix|update|add|build|test|install|start|try|"
+    r"fetch|list|compare|construct|draft|prepare|explore|query|confirm|diff|do)\b",
+    re.I,
+)
+_HANDED_TO_USER_RE = re.compile(
+    r"\b(?:when|if|once|whenever|after) you\b|\byour (?:call|go-ahead|word|court)\b|"
+    r"\band i(?:'ll| will)\b|\b(?:tell|give|ask|show) me\b|\bsay (?:the word|which|'|\")", re.I)
+
+
+def _announces_next_step(stripped: str) -> bool:
+    """True if the reply's last paragraph says what the model will do NEXT (and it did not
+    do it). Pure, so the live replies can be replayed."""
+    paras = [p for p in re.split(r"\n\s*\n", stripped or "") if p.strip()]
+    if not paras:
+        return False
+    last = paras[-1]
+    return bool(_NEXT_STEP_RE.search(last)) and not _HANDED_TO_USER_RE.search(last)
+
+
 def _looks_like_scratchpad(stripped: str) -> bool:
     """True if `stripped` reads like unresolved internal deliberation rather than a
-    finished, user-facing answer — see module comment above for the two signals used."""
+    finished, user-facing answer — see module comment above for the signals used."""
     if _SCRATCHPAD_START_RE.match(stripped):
         return True
+    if _announces_next_step(stripped):
+        return True
     return len(_DELIBERATION_RE.findall(stripped)) >= 3
 
 
@@ -5224,6 +5258,37 @@ def _has_runnable_block(text) -> bool:
         return False
 
 
+# Chat-template control tokens a served model sometimes prints instead of acting on (#139,
+# Kimi K3 on ollama.com: "Thought: …<|close|>think<|sep|><|open|>response<|sep|>"). They mark
+# where the model's own reasoning ended and its reply began.
+_TEMPLATE_TOKEN_RE = re.compile(r"<\|[a-z_]{2,24}\|>(?:\s*[a-z_]{2,24}\s*<\|[a-z_]{2,24}\|>)*", re.I)
+
+
+def _strip_leaked_template(content):
+    """Cut leaked chat-template tokens out of a reply; keep what came after the last one.
+
+    Text before the last token is the model's reasoning written into the visible channel; text
+    after it is the reply. An EMPTY reply stays empty, so the empty-content nudge asks the model
+    to act instead of the step failing on a plan that ran nothing (seen live: three steps of
+    "Thought: … now final answer.<|close|>think…" before a final_answer). Tokens inside a
+    <code> block are file content, never ours to touch."""
+    if not isinstance(content, str) or "<|" not in content:
+        return content
+    spans = [m.span() for m in re.finditer(_CODE_PAIR_RE, content, re.I)]
+    last = None
+    for m in _TEMPLATE_TOKEN_RE.finditer(content):
+        if not any(a <= m.start() < b for a, b in spans):
+            last = m
+    if last is None:
+        return content
+    reply = content[last.end():].strip()
+    if reply:
+        return reply
+    head = _TEMPLATE_TOKEN_RE.sub("", content[:last.start()]).strip()
+    # A runnable block before the tokens is still the action — keep it.
+    return head if _has_runnable_block(head) else ""
+
+
 def _code_nudge_reason(content, openai_backend: bool):
     """Why (if at all) this streamed turn should be re-prompted once with the CODE-NOW
     directive — or None to accept it as-is. Pure decision so the three triggers can be
@@ -5234,14 +5299,16 @@ def _code_nudge_reason(content, openai_backend: bool):
          merely TRUNCATED at the `</code>` stop sequence is not that (task #119): it is
          closed first and accepted as-is, so a step that already called a tool no longer
          pays for a second model call to be told to do what it just did.
-      3. prose-only plan — narration of what it is ABOUT to do, no tag at all. This one
-         is openai-only and additionally requires _looks_like_scratchpad, so a FINISHED
-         prose answer is never nudged into inventing another tool call. It exists because
-         the "</code>" visible in a smolagents trace is appended by smolagents AFTER the
-         model returns, so trigger 2 cannot see this shape.
-
-    Triggers 1 and 2 keep their existing backend-agnostic behavior — the Ollama path is
-    unchanged, since trigger 3 is the only new one and it is gated off there."""
+      3. prose-only plan — narration of what it is ABOUT to do, no tag at all. It
+         requires _looks_like_scratchpad, so a FINISHED prose answer is never nudged into
+         inventing another tool call. It exists because the "</code>" visible in a
+         smolagents trace is appended by smolagents AFTER the model returns, so trigger 2
+         cannot see this shape.
+
+    All three apply on every backend. Trigger 3 was openai-only (kept off small local
+    Ollama models); #139 showed the cost: Kimi K3 served by ollama.com is an "ollama"
+    backend, so each plan-only reply burned a whole failed step instead of one retry.
+    `openai_backend` is kept for callers and no longer changes the decision."""
     text = (content or "").strip()
     if not text:
         return "empty-content"
@@ -5249,7 +5316,7 @@ def _code_nudge_reason(content, openai_backend: bool):
         return None  # a real block (closing a stop-truncated one first) — nothing to nudge
     if re.search(r"</?code[\s>/]", content, re.I):
         return "dangling code tag, no valid block"
-    if openai_backend and _looks_like_scratchpad(text):
+    if _looks_like_scratchpad(text):
         return "prose-only plan, no code block"
     return None
 
@@ -10160,7 +10227,10 @@ def run_agent_chat(cfg):
         "find a URL, THEN fetch_url to read it). You SEE the Observation before the next step. "
         "When you have enough to answer, call final_answer(<your answer>) in a code block — pass a readable "
         "markdown/prose recap (what you did, what you verified, what is left), never a dict, list or JSON. "
-        "Prefer FEWER steps, and never repeat a tool call that already succeeded.\n\n"
+        "Prefer FEWER steps, and never repeat a tool call that already succeeded. "
+        # #139: Kimi K3 replied "…Let me check X" with no block, and that plan became the answer.
+        "A reply WITHOUT a code block ENDS your turn and is shown to the user as your answer — "
+        "never end on \"Let me check…\"; if there is more to do, put that call in the block NOW.\n\n"
         "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
         + _skills_mod.prompt_block(_skills)
         + _rag_tool_block + _ws_tool_block + _auto_test_block +
@@ -11730,6 +11800,12 @@ def run_agent_chat(cfg):
             # anything downstream asks "did this turn produce a code block?" — otherwise a
             # step that called a tool correctly reads as broken. Gated on the code actually
             # compiling, so a genuinely dangling tag still falls through to the nudge below.
+            # Leaked chat-template tokens first (#139): what came before them is reasoning.
+            _unleaked = _strip_leaked_template(content)
+            if _unleaked != content:
+                _log(f"leaked chat-template tokens → kept the reply after them "
+                     f"({len(content)} → {len(_unleaked)} chars)")
+                content = _unleaked
             content = _close_dangling_code_block(content)
             # TAGS FIRST, judgement second. The tag repair used to run much later, so every
             # decision in between — is this a code block? does it need a nudge? — was made on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.823",
+  "version": "1.0.825",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",