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

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.
@@ -1773,6 +1805,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:
@@ -1811,7 +1922,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)
@@ -1841,10 +1952,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
@@ -1972,13 +2093,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.140",
+  "version": "1.0.142",
   "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",