@tiens.nguyen/gonext-local-worker 1.0.54 → 1.0.56

package/gonext-local-worker.mjs

@@ -1237,7 +1237,7 @@ async function runAgentChatJob(job) {
       agentApiKey: payload?.agentApiKey ?? "",
       agentModelId: payload?.agentModelId ?? "",
       tools: payload?.tools ?? ["http_request"],
-      maxSteps: payload?.maxSteps ?? 10,
+      maxSteps: payload?.maxSteps ?? 5,
     });
     const timeoutMs = 300_000; // 5 min max for an agent run
 
@@ -1245,7 +1245,9 @@ async function runAgentChatJob(job) {
     let finalText = "";
 
     await runProcessWithStreamingStdout(python, [scriptPath], input, timeoutMs, (event) => {
-      if (event.type === "step" && typeof event.text === "string") {
+      if (event.type === "log" && typeof event.text === "string") {
+        console.log(`[gonext-agent] ${event.text}`);
+      } else if (event.type === "step" && typeof event.text === "string") {
         if (!inThink) {
           inThink = true;
           enqueueText("<think>");

package/gonext_agent_chat.py

@@ -12,17 +12,14 @@ Reads on stdin:
     "maxSteps": int              # default 10
   }
 
-Emits NDJSON lines on stdout per step/final:
-  {"type": "step",  "text": "<tool call summary>"}
-  {"type": "final", "text": "<agent final answer>"}
-
-All smolagents/rich console output goes to stderr so stdout stays clean.
-
-TLS: uses certifi CA bundle when available (macOS may lack system certs for
-Python urllib), with fallback to the default bundle.
+Emits NDJSON lines on stdout:
+  {"type": "log",   "text": "..."}   — worker logs to console, not shown in chat
+  {"type": "step",  "text": "..."}   — shown in <think> area
+  {"type": "final", "text": "..."}   — assistant answer
 """
 import contextlib
 import json
+import re
 import sys
 import urllib.request
 import urllib.error
@@ -63,6 +60,61 @@ def _http_request_impl(method, url, headers=None, body=None, timeout=20):
         return f"Error: {e}"
 
 
+def _summarise_step(step_log):
+    """Return a short human-readable description of an agent step."""
+    tool_calls = getattr(step_log, "tool_calls", None) or []
+    observations = getattr(step_log, "observations", None)
+    error = getattr(step_log, "error", None)
+    step_num = getattr(step_log, "step_number", None)
+
+    parts = []
+    for tc in tool_calls:
+        name = getattr(tc, "name", "")
+        args = getattr(tc, "arguments", None)
+
+        if name == "python_interpreter" and isinstance(args, dict):
+            code = args.get("code", "")
+            # Show the http_request call if present, else first meaningful line
+            m = re.search(r'http_request\s*\(\s*(?:method\s*=\s*)?[\'"]?(\w+)[\'"]?\s*,\s*(?:url\s*=\s*)?[\'"]([^\'"]+)', code)
+            if m:
+                parts.append(f"HTTP {m.group(1).upper()} {m.group(2)}")
+            else:
+                first = next(
+                    (l.strip() for l in code.splitlines()
+                     if l.strip() and not l.strip().startswith("#")),
+                    code[:80],
+                )
+                parts.append(first[:120])
+        else:
+            if isinstance(args, dict):
+                method = args.get("method", "")
+                url = args.get("url", "")
+                if method and url:
+                    parts.append(f"HTTP {method.upper()} {url}")
+                else:
+                    parts.append(f"{name}()")
+            else:
+                parts.append(name or "tool call")
+
+    if observations:
+        obs = str(observations).strip()
+        # smolagents prefixes output with "Execution logs:" — skip that header line
+        # and show the first line of actual content.
+        lines = [l for l in obs.splitlines() if l.strip() and l.strip() != "Execution logs:"]
+        if lines:
+            parts.append(f"→ {lines[0][:200]}")
+
+    if error:
+        err = str(error)
+        if "Import of" in err and "not allowed" in err:
+            parts.append("→ (import blocked — using http_request tool instead)")
+        else:
+            parts.append(f"→ Error: {err[:120]}")
+
+    label = f"Step {step_num}: " if step_num is not None else ""
+    return label + (" | ".join(parts) if parts else "thinking…")
+
+
 def run_agent_chat(cfg):
     try:
         from smolagents import CodeAgent, OpenAIServerModel, tool
@@ -74,9 +126,11 @@ def run_agent_chat(cfg):
     agent_base_url = cfg.get("agentBaseURL") or ""
     agent_api_key = cfg.get("agentApiKey") or "local"
     agent_model_id = cfg.get("agentModelId") or ""
-    max_steps = int(cfg.get("maxSteps") or 10)
+    max_steps = int(cfg.get("maxSteps") or 5)
+
+    _log(f"start model={agent_model_id!r} base={agent_base_url!r} maxSteps={max_steps}")
 
-    # Build the task from the last user message; use prior turns as context.
+    # Build task from the last user message; prepend prior assistant turns as context.
     task_text = ""
     context_lines = []
     for m in messages:
@@ -94,9 +148,22 @@ def run_agent_chat(cfg):
     if context_lines:
         task_text = "\n".join(context_lines) + "\n\nNow answer: " + task_text
 
+    # Prepend explicit tool instructions so small models use http_request correctly
+    # and always terminate with final_answer() rather than looping forever.
+    tool_hint = (
+        "You have ONE built-in function: `http_request(method, url, headers='', body='')`. "
+        "Do NOT import requests, urllib, or any library — call http_request() directly.\n"
+        "When you have the answer, ALWAYS end with `final_answer(your_answer)` — this stops the agent.\n"
+        "Example:\n"
+        "result = http_request(method='GET', url='https://example.com')\n"
+        "final_answer(result)\n\n"
+    )
+    task_with_hint = tool_hint + "Task: " + task_text
+    _log(f"task={task_text[:120]!r}")
+
     @tool
     def http_request(method: str, url: str, headers: str = "", body: str = "") -> str:
-        """Perform an HTTP request and return the status code and a body preview.
+        """Perform an HTTP request and return the status code and body preview.
 
         Args:
             method: HTTP method (GET, POST, PUT, DELETE, etc.)
@@ -110,30 +177,16 @@ def run_agent_chat(cfg):
                 parsed_headers = json.loads(headers)
             except Exception:  # noqa: BLE001
                 pass
-        return _http_request_impl(method, url, parsed_headers, body or None)
+        result = _http_request_impl(method, url, parsed_headers, body or None)
+        _log(f"http_request {method.upper()} {url} → {result[:80]}")
+        return result
 
     def step_callback(step_log):
         try:
-            parts = []
-            # tool_calls is a list of ToolCall(name, arguments, id)
-            tool_calls = getattr(step_log, "tool_calls", None) or []
-            for tc in tool_calls:
-                name = getattr(tc, "name", str(tc))
-                args = getattr(tc, "arguments", None)
-                arg_str = json.dumps(args) if args is not None else ""
-                parts.append(f"Tool: {name}({arg_str})")
-            observations = getattr(step_log, "observations", None)
-            if observations:
-                parts.append(f"→ {str(observations)[:400]}")
-            error = getattr(step_log, "error", None)
-            if error:
-                parts.append(f"Error: {error}")
-            if not parts:
-                parts.append(str(step_log)[:300])
-            text = " ".join(parts)
+            text = _summarise_step(step_log)
         except Exception as e:  # noqa: BLE001
             text = f"Step: {e}"
-
+        _log(f"step: {text[:200]}")
         _emit({"type": "step", "text": text})
 
     try:
@@ -150,21 +203,24 @@ def run_agent_chat(cfg):
             executor_kwargs={"timeout_seconds": 60},
             additional_authorized_imports=["json", "urllib", "urllib.request", "urllib.error"],
         )
-        # Emit before agent.run() so the web no-progress timer resets while the
-        # model loads its weights and generates its first reasoning step.
         _emit({"type": "step", "text": f"Sending task to {agent_model_id}…"})
         with contextlib.redirect_stdout(sys.stderr):
-            result = agent.run(task_text)
+            result = agent.run(task_with_hint)
         final_text = str(result).strip()
+        _log(f"done: {len(final_text)} chars")
         _emit({"type": "final", "text": final_text})
     except Exception as e:  # noqa: BLE001
+        _log(f"agent error: {e}")
         _emit({"type": "final", "text": f"[Agent error: {e}]"})
 
 
+def _log(text: str):
+    """Emit a log event — worker prints it to console, not forwarded to chat."""
+    _emit({"type": "log", "text": text})
+
+
 def _emit(obj):
-    """Write one NDJSON line to the real stdout and flush immediately.
-    Uses _REAL_STDOUT (captured at import time) so redirect_stdout blocks
-    inside agent.run() don't accidentally route events to stderr."""
+    """Write one NDJSON line to the real stdout and flush immediately."""
     _REAL_STDOUT.write(json.dumps(obj) + "\n")
     _REAL_STDOUT.flush()
 

package/package.json

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