@tiens.nguyen/gonext-local-worker 1.0.140 → 1.0.141

package/gonext_agent_chat.py

@@ -634,6 +634,38 @@ 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)
+_CODE_CLOSE_TAG = re.compile(r"<\s*/\s*code\s*>", 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(
+    r"```(?:py|python)?[ \t]*\r?\n(.*?)```", re.DOTALL | re.IGNORECASE
+)
+
+
+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."""
+    if not text:
+        return text
+    fixed = _CODE_OPEN_TAG.sub("<code>", text)
+    fixed = _CODE_CLOSE_TAG.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)
+    return fixed
+
 
 def _strip_think(text: str) -> str:
     """Remove Qwen3-style <think>…</think> reasoning traces from a model reply.
@@ -1841,10 +1873,20 @@ def run_agent_chat(cfg):
                 if content is None:
                     _log("model returned content=None (empty/thinking-only turn) → coercing to ''")
                     msg.content = ""
+                    content = ""
                 elif isinstance(content, str) and "</think>" in content.lower():
                     cleaned = _strip_think(content)
                     _log(f"stripped <think> trace ({len(content) - len(cleaned)} chars)")
                     msg.content = cleaned
+                    content = cleaned
+                # Normalize code-block delimiters so smolagents' <code>…</code> parser
+                # matches even when the model wrote "<code >" / a markdown fence. Without
+                # this, tag-whitespace variants fail EVERY step → "Reached max steps".
+                if isinstance(content, str) and content:
+                    normalized = _normalize_code_tags(content)
+                    if normalized != content:
+                        _log("normalized code-block tags (<code >/fence → <code>)")
+                        msg.content = normalized
             except Exception as e:  # noqa: BLE001
                 _log(f"content-normalize error: {e}")
             return msg

package/package.json

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