@tiens.nguyen/gonext-local-worker 1.0.60 → 1.0.62

package/gonext_agent_chat.py

@@ -32,18 +32,20 @@ _REAL_STDOUT = sys.stdout
 
 def _ssl_context():
     import ssl
-    try:
-        import certifi
-        return ssl.create_default_context(cafile=certifi.where())
-    except ImportError:
-        return ssl.create_default_context()
+    # Disable cert verification — this agent runs locally against dev tunnels
+    # (gorok, ngrok) whose certs may not chain correctly in Python's SSL store.
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    return ctx
 
 
 def _http_request_impl(method, url, headers=None, body=None, timeout=25):
-    req = urllib.request.Request(url, method=method.upper())
+    # Merge caller headers on top of sensible defaults.
+    merged = {"User-Agent": "gonext-agent/1.0", "Accept": "*/*"}
     if headers:
-        for k, v in headers.items():
-            req.add_header(k, v)
+        merged.update(headers)
+    req = urllib.request.Request(url, method=method.upper(), headers=merged)
     data = body.encode() if isinstance(body, str) and body else (body or None)
     try:
         ctx = _ssl_context()
@@ -115,6 +117,55 @@ def _summarise_step(step_log):
     return label + (" | ".join(parts) if parts else "thinking…")
 
 
+def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
+    """Ask the local model if this task needs an HTTP request.
+    Returns True → run full agent; False → plain chat reply."""
+    try:
+        from openai import OpenAI
+        client = OpenAI(base_url=base_url, api_key=api_key or "local",
+                        max_retries=0, timeout=20)
+        resp = client.chat.completions.create(
+            model=model_id,
+            messages=[
+                {"role": "system", "content": (
+                    "You are a task classifier. Reply with YES or NO only, no punctuation."
+                )},
+                {"role": "user", "content": (
+                    f"Does this task require making an HTTP request to a URL or API?\n\n"
+                    f"Task: {task_text}\n\nYES or NO:"
+                )},
+            ],
+            max_tokens=3,
+            temperature=0,
+        )
+        answer = (resp.choices[0].message.content or "").strip().upper()
+        _log(f"router → {answer!r}")
+        return answer.startswith("Y")
+    except Exception as e:  # noqa: BLE001
+        _log(f"router error: {e} — defaulting to agent")
+        return True
+
+
+def _plain_reply(task_text: str, base_url: str, api_key: str, model_id: str) -> str:
+    """Plain chat completion without any tools."""
+    try:
+        from openai import OpenAI
+        client = OpenAI(base_url=base_url, api_key=api_key or "local",
+                        max_retries=0, timeout=60)
+        resp = client.chat.completions.create(
+            model=model_id,
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": task_text},
+            ],
+            temperature=0.7,
+            max_tokens=512,
+        )
+        return (resp.choices[0].message.content or "").strip()
+    except Exception as e:  # noqa: BLE001
+        return f"[Error: {e}]"
+
+
 def run_agent_chat(cfg):
     try:
         from smolagents import CodeAgent, OpenAIServerModel, tool
@@ -130,29 +181,31 @@ def run_agent_chat(cfg):
 
     _log(f"start model={agent_model_id!r} base={agent_base_url!r} maxSteps={max_steps}")
 
-    # Build task from the last user message; prepend prior assistant turns as context.
-    # Strip <think>...</think> blocks from assistant messages — those are internal
-    # reasoning steps and must not be fed back to the agent as conversation context.
-    _THINK_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
-
+    # Use only the latest user message as the agent task.
     task_text = ""
-    context_lines = []
     for m in messages:
-        role = m.get("role", "")
-        content = m.get("content", "")
-        if role == "user":
-            task_text = content
-        elif role == "assistant":
-            clean = _THINK_RE.sub("", content).strip()
-            if clean:
-                context_lines.append(f"Assistant previously said: {clean[:500]}")
+        if m.get("role") == "user":
+            task_text = m.get("content", "")
 
     if not task_text:
         _emit({"type": "final", "text": "[No user message found in history]"})
         return
 
-    if context_lines:
-        task_text = "\n".join(context_lines) + "\n\nNow answer: " + task_text
+    _log(f"task={task_text[:120]!r}")
+
+    # Route: ask the model if this task needs HTTP tool use.
+    _emit({"type": "step", "text": "Routing…"})
+    needs_agent = _route(task_text, agent_base_url, agent_api_key, agent_model_id)
+
+    if not needs_agent:
+        _log("router: plain chat (no HTTP needed)")
+        _emit({"type": "step", "text": "No HTTP request needed — answering directly…"})
+        answer = _plain_reply(task_text, agent_base_url, agent_api_key, agent_model_id)
+        _log(f"plain reply: {len(answer)} chars")
+        _emit({"type": "final", "text": answer})
+        return
+
+    _log("router: agent (HTTP tool use needed)")
 
     # Prepend explicit tool instructions so small models use http_request correctly
     # and always terminate with final_answer() rather than looping forever.
@@ -165,7 +218,6 @@ def run_agent_chat(cfg):
         "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:

package/package.json

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