@tiens.nguyen/gonext-local-worker 1.0.142 → 1.0.144

package/gonext_agent_chat.py

@@ -482,6 +482,12 @@ def _summarise_step(step_log):
         err = str(error)
         if "Import of" in err and "not allowed" in err:
             parts.append("→ (import blocked — using http_request tool instead)")
+        elif "reached max steps" in err.lower() or "max steps" in err.lower():
+            # NOT a user-facing failure: hitting the step budget triggers our
+            # provide_final_answer override, which ALWAYS delivers a synthesized answer
+            # (a rendered PDF, the last tool result, or a plain reply). Surfacing the raw
+            # "Error: Reached max steps." made a successful run look failed (task #10).
+            parts.append("→ Wrapping up (reached step budget)…")
         else:
             parts.append(f"→ Error: {err[:120]}")
 
@@ -634,14 +640,23 @@ def _strip_tool_tags(text: str) -> str:
 
 _THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 
-# Whitespace/attr variants of smolagents' code-block tags. Weak models routinely
-# emit "<code >" (trailing space), "< code >", "</ code>", or an uppercase form —
-# none of which match smolagents' exact "<code>(.*?)</code>" parser, so EVERY step
-# fails with "regex pattern <code>(.*?)</code> was not found" and the run burns all
-# its steps. Normalizing the tags to the canonical form before the parser sees them
-# turns that spiral into a normal, parseable step.
-_CODE_OPEN_TAG = re.compile(r"<\s*code(?:\s[^>]*)?\s*>", re.IGNORECASE)
+# Malformed variants of smolagents' code-block tags. Weak coding models routinely
+# emit "<code >" (trailing space), "< code >", "</ code>", "<CODE>", OR — worst —
+# "<code print(x) </code>" where the OPENING tag is missing its ">" entirely. None
+# match smolagents' exact "<code>(.*?)</code>" parser, so EVERY step fails with
+# "regex pattern <code>(.*?)</code> was not found" and the run burns all its steps.
+# Normalizing the tags to canonical form before the parser sees them turns that
+# spiral into a normal, parseable step.
 _CODE_CLOSE_TAG = re.compile(r"<\s*/\s*code\s*>", re.IGNORECASE)
+# A well-formed-ISH open tag that DOES have a ">": "<code>", "<code >", "< code >",
+# "<CODE>", "<code class=py>". Critically the attr span is [^<>] (NOT [^>]) so it can
+# never swallow across the "<" of a following "</code>" — the bug that collapsed
+# "<code print(x) </code>" to a bare "<code>" and destroyed the code.
+_CODE_OPEN_TAG = re.compile(r"<\s*code\b[^<>]*>", re.IGNORECASE)
+# An open tag MISSING its ">": "<code" not immediately followed by ">". \b keeps it
+# from matching "<codeblock"/"<coder"; the lookahead skips the already-canonical
+# "<code>" so this pass only rescues the no-">" case.
+_CODE_OPEN_NO_GT = re.compile(r"<\s*code\b(?!>)", re.IGNORECASE)
 # Fallback: a markdown code fence (```py / ```python / ```) when the model ignored
 # the tag convention entirely. Captures the fenced body so we can re-wrap it.
 _MD_FENCE_BLOCK = re.compile(
@@ -652,18 +667,25 @@ _MD_FENCE_BLOCK = re.compile(
 def _normalize_code_tags(text: str) -> str:
     """Coerce a model reply's code-block delimiters to smolagents' exact <code>…</code>.
 
-    Handles the two failure modes seen live with weak coding models:
-      1. tag whitespace/case: "<code >", "< code >", "</ code>", "<CODE>" → "<code>".
-      2. markdown fences instead of tags: ```py … ``` → <code> … </code> (only when
-         no <code> tag is present after step 1, so we don't touch code that legitimately
-         contains backticks inside a real <code> block).
-    Returns text unchanged when it already parses cleanly."""
+    Handles the failure modes seen live with weak coding models:
+      1. close-tag variants: "</ code>", "< / code >" → "</code>" (done FIRST so the
+         open-tag pass has a canonical "<" boundary to stop at).
+      2. open-tag-with-">": "<code >", "< code >", "<CODE>", "<code attr>" → "<code>".
+      3. open-tag-missing-">": "<code print(x) </code>" → "<code> print(x) </code>".
+      4. markdown fences instead of tags: ```py … ``` → <code>…</code> (only when no
+         <code> tag is present, so we don't touch backticks inside a real <code> block).
+      5. opened-but-never-closed (exactly one "<code>", no "</code>"): append "</code>"
+         so the parser can still extract the code instead of failing the whole step.
+    Idempotent — already-correct "<code>…</code>" is returned unchanged."""
     if not text:
         return text
-    fixed = _CODE_OPEN_TAG.sub("<code>", text)
-    fixed = _CODE_CLOSE_TAG.sub("</code>", fixed)
+    fixed = _CODE_CLOSE_TAG.sub("</code>", text)
+    fixed = _CODE_OPEN_TAG.sub("<code>", fixed)
+    fixed = _CODE_OPEN_NO_GT.sub("<code>", fixed)
     if "<code>" not in fixed:
         fixed = _MD_FENCE_BLOCK.sub(lambda m: f"<code>\n{m.group(1)}</code>", fixed, count=1)
+    if fixed.count("<code>") == 1 and "</code>" not in fixed:
+        fixed = fixed + "\n</code>"
     return fixed
 
 
@@ -1850,10 +1872,13 @@ def run_agent_chat(cfg):
             # Ollama honors it). Harmless if the server ignores it — usage stays 0.
             completion_kwargs["stream_options"] = {"include_usage": True}
             self._apply_rate_limit()
+            t0 = time.monotonic()
+            _log("streamed generate: request issued (stream=True), awaiting first token…")
             stream = self.client.chat.completions.create(**completion_kwargs)
             parts = []
             role = "assistant"
             in_tok = out_tok = 0
+            first_token_at = None
             for chunk in stream:
                 usage = getattr(chunk, "usage", None)
                 if usage is not None:
@@ -1869,6 +1894,17 @@ def run_agent_chat(cfg):
                     role = delta.role
                 piece = getattr(delta, "content", None)
                 if piece:
+                    if first_token_at is None:
+                        # First streamed byte. The gap t0→here is pure prompt-eval time
+                        # (server sent nothing before this); everything after is token
+                        # generation with bytes flowing, so the proxy idle timer resets.
+                        # If this line never appears in the log, the request died in
+                        # prompt-eval BEFORE any token — streaming can't help there
+                        # (shrink the model / warm the prompt cache instead).
+                        first_token_at = time.monotonic()
+                        _log(f"streamed generate: FIRST token after {first_token_at - t0:.1f}s "
+                             "(prompt-eval done; tokens now flowing)")
+                        _emit({"type": "step", "text": "Model is responding…"})
                     parts.append(piece)
             content = "".join(parts)
             if stop_sequences and not self.supports_stop_parameter:

package/package.json

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