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

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
 
 
@@ -1805,6 +1827,85 @@ def run_agent_chat(cfg):
     # and any step memory it accumulates. completion_kwargs["messages"] here is the
     # literal messages array sent to /v1/chat/completions.
     class _LoggingModel(OpenAIServerModel):
+        def __init__(self, *a, stream_agent=False, **kw):
+            # stream_agent: request the completion with stream=True and reassemble the
+            # deltas into one message. Enabled for Ollama, where a long single-shot
+            # (non-stream) generation sends nothing until the very end — a reverse proxy
+            # in front of the box (ollama1.gomarsic.cc) then hits its idle read-timeout
+            # and kills the request mid-generation. Streaming keeps tokens flowing so the
+            # idle timer never fires. smolagents still receives the COMPLETE text, so its
+            # <code>/final_answer parsing is unaffected.
+            self._stream_agent = bool(stream_agent)
+            super().__init__(*a, **kw)
+
+        def _generate_once(self, *args, **kwargs):
+            """One model call. Streams + reassembles when _stream_agent, else the normal
+            non-streaming path. Streaming is a pure transport optimization: on ANY failure
+            it falls back to the non-streaming call, and it's skipped for tool-calling
+            mode (tools_to_call_from), whose tool_call deltas we don't reassemble."""
+            tools_to_call_from = kwargs.get("tools_to_call_from")
+            if not self._stream_agent or tools_to_call_from:
+                return super().generate(*args, **kwargs)
+            try:
+                return self._streamed_generate(*args, **kwargs)
+            except Exception as e:  # noqa: BLE001
+                _log(f"streamed generate failed ({e}) → falling back to non-streaming")
+                return super().generate(*args, **kwargs)
+
+        def _streamed_generate(
+            self, messages, stop_sequences=None, response_format=None,
+            tools_to_call_from=None, **kwargs,
+        ):
+            from smolagents.models import ChatMessage, TokenUsage  # local: version-safe
+            completion_kwargs = self._prepare_completion_kwargs(
+                messages=messages,
+                stop_sequences=stop_sequences,
+                response_format=response_format,
+                tools_to_call_from=tools_to_call_from,
+                model=self.model_id,
+                custom_role_conversions=self.custom_role_conversions,
+                convert_images_to_image_urls=True,
+                **kwargs,
+            )
+            completion_kwargs["stream"] = True
+            # Ask for a usage summary in the final chunk (OpenAI streaming convention;
+            # Ollama honors it). Harmless if the server ignores it — usage stays 0.
+            completion_kwargs["stream_options"] = {"include_usage": True}
+            self._apply_rate_limit()
+            stream = self.client.chat.completions.create(**completion_kwargs)
+            parts = []
+            role = "assistant"
+            in_tok = out_tok = 0
+            for chunk in stream:
+                usage = getattr(chunk, "usage", None)
+                if usage is not None:
+                    in_tok = getattr(usage, "prompt_tokens", 0) or in_tok
+                    out_tok = getattr(usage, "completion_tokens", 0) or out_tok
+                choices = getattr(chunk, "choices", None)
+                if not choices:
+                    continue
+                delta = getattr(choices[0], "delta", None)
+                if delta is None:
+                    continue
+                if getattr(delta, "role", None):
+                    role = delta.role
+                piece = getattr(delta, "content", None)
+                if piece:
+                    parts.append(piece)
+            content = "".join(parts)
+            if stop_sequences and not self.supports_stop_parameter:
+                from smolagents.models import remove_content_after_stop_sequences
+                content = remove_content_after_stop_sequences(content, stop_sequences)
+            _log(f"streamed generate assembled {len(content)} chars "
+                 f"(in={in_tok} out={out_tok} tokens)")
+            return ChatMessage(
+                role=role,
+                content=content,
+                tool_calls=None,
+                raw=None,
+                token_usage=TokenUsage(input_tokens=in_tok, output_tokens=out_tok),
+            )
+
         def generate(self, *args, **kwargs):
             # Two safeguards on each step's reply BEFORE smolagents parses it for the
             # code block / final_answer:
@@ -1843,7 +1944,7 @@ def run_agent_chat(cfg):
             try:
                 for attempt in range(3):
                     try:
-                        msg = super().generate(*args, **kwargs)
+                        msg = self._generate_once(*args, **kwargs)
                         break
                     except Exception as e:  # noqa: BLE001
                         emsg = str(e)
@@ -2014,13 +2115,17 @@ def run_agent_chat(cfg):
         # the live test — minutes per step on a slow GPU — so disable it explicitly.
         # Sniffed per-server because MLX might reject the unknown param.
         extra_model_kwargs = {}
-        if _is_ollama_server(coding_base_url):
-            _log("coding server is Ollama → sending reasoning_effort='none' to disable thinking")
+        coding_is_ollama = _is_ollama_server(coding_base_url)
+        if coding_is_ollama:
+            _log("coding server is Ollama → reasoning_effort='none' (disable thinking) + streaming")
             extra_model_kwargs["reasoning_effort"] = "none"
         model = _LoggingModel(
             model_id=coding_model_id,
             api_base=coding_base_url,
             api_key=agent_api_key,
+            # Stream for Ollama so a long generation keeps the connection warm and can't
+            # trip a reverse-proxy idle read-timeout. smolagents still gets the full text.
+            stream_agent=coding_is_ollama,
             # Cap each HTTP attempt at 600s so a genuinely slow single call (a
             # remote M6000/Vulkan box doing a cold ~4-5min prompt-eval) can finish
             # on the first try, while a truly hung request still fails into OUR

package/package.json

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