@tiens.nguyen/gonext-local-worker 1.0.87 → 1.0.89

package/gonext_agent_chat.py

@@ -64,6 +64,80 @@ def _http_request_impl(method, url, headers=None, body=None, timeout=25):
         return f"Error: {e}"
 
 
+def _get_json(url, timeout=15):
+    """GET a URL and parse the JSON body. Returns dict/list, or None on failure.
+
+    Used by web_search against free no-key APIs (DuckDuckGo, Wikipedia). Wikipedia
+    requires a descriptive User-Agent, so we send one.
+    """
+    req = urllib.request.Request(url, method="GET", headers={
+        "User-Agent": "gonext-agent/1.0 (local API testing assistant)",
+        "Accept": "application/json",
+    })
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_context()) as resp:
+            return json.loads(resp.read().decode("utf-8", errors="replace"))
+    except Exception as e:  # noqa: BLE001
+        _log(f"web_search fetch failed {url}: {e}")
+        return None
+
+
+def _web_search_impl(query):
+    """Look up factual info via free no-key JSON APIs (DuckDuckGo + Wikipedia).
+
+    Returns a short text summary with a source URL, or a 'no results' message.
+    Tries DuckDuckGo Instant Answer first, then falls back to a Wikipedia search +
+    REST summary. Never fabricates — callers should surface 'no results' honestly.
+    """
+    from urllib.parse import quote
+    q = (query or "").strip()
+    if not q:
+        return "web_search: empty query."
+
+    # 1) DuckDuckGo Instant Answer API.
+    ddg = _get_json(
+        f"https://api.duckduckgo.com/?q={quote(q)}&format=json&no_html=1&skip_disambig=1"
+    )
+    if isinstance(ddg, dict):
+        abstract = (ddg.get("AbstractText") or "").strip()
+        if abstract:
+            src = (ddg.get("AbstractURL") or "").strip()
+            return f"{abstract[:1500]}\nSource: {src}" if src else abstract[:1500]
+        # No abstract — use the first related topic that has text.
+        for topic in ddg.get("RelatedTopics") or []:
+            if isinstance(topic, dict) and topic.get("Text"):
+                src = (topic.get("FirstURL") or "").strip()
+                text = topic["Text"][:1500]
+                return f"{text}\nSource: {src}" if src else text
+
+    # 2) Wikipedia: find the best-matching title, then fetch its summary extract.
+    search = _get_json(
+        "https://en.wikipedia.org/w/api.php?action=query&list=search"
+        f"&srsearch={quote(q)}&format=json&srlimit=1"
+    )
+    title = ""
+    try:
+        title = search["query"]["search"][0]["title"]
+    except Exception:  # noqa: BLE001
+        title = ""
+    if title:
+        slug = quote(title.replace(" ", "_"))
+        summary = _get_json("https://en.wikipedia.org/api/rest_v1/page/summary/" + slug)
+        if isinstance(summary, dict):
+            extract = (summary.get("extract") or "").strip()
+            if extract:
+                src = (
+                    (summary.get("content_urls") or {}).get("desktop", {}).get("page", "")
+                    or f"https://en.wikipedia.org/wiki/{slug}"
+                )
+                return f"{extract[:1500]}\nSource: {src}"
+
+    return (
+        f"No results found for '{q}'. Tell the user you couldn't find this — "
+        "do NOT invent an answer or a URL."
+    )
+
+
 def _detect_model_id(base_url, api_key=""):
     """Ask an OpenAI-compatible server which model it serves.
 
@@ -154,6 +228,8 @@ _AGENT_KEYWORDS = re.compile(
     r"|external\s+source|external\s+api|external\s+service"
     r"|web\s+service|rest\s+api|rest\s+call"
     r"|download|scrape|crawl"
+    r"|search|find|look\s*up|lookup|weather|news|latest|current|today|tonight"
+    r"|date|time|what\s+day|what\s+time"
     r")\b",
     re.IGNORECASE,
 )
@@ -180,8 +256,10 @@ def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
                 {"role": "system", "content": (
                     "You are a task classifier. Reply YES or NO only, no punctuation.\n"
                     "Answer YES if the task requires fetching data from an external network source "
-                    "(URL, API, website, web service, or any remote server).\n"
-                    "Answer NO if it can be solved entirely with Python stdlib, math, or is just conversation."
+                    "(URL, API, website, remote server), a web search / factual lookup, or the "
+                    "current date or time.\n"
+                    "Answer NO only if it is pure conversation, opinion, or simple text the "
+                    "assistant can answer directly without looking anything up."
                 )},
                 {"role": "user", "content": (
                     f"Does this task require fetching data from an external network source?\n\n"
@@ -330,6 +408,10 @@ def run_agent_chat(cfg):
         _emit({"type": "final", "text": "[No user message found in history]"})
         return
     task_text = (messages[last_user_idx].get("content") or "").strip()
+    # Routing must look at the CURRENT message alone — not the history-laden blob
+    # below. Otherwise the keyword router matches URLs/"api"/"GET" from prior turns
+    # and fires the agent on trivial replies like "thanks" or "good".
+    latest_user_text = task_text
 
     # Walk prior turns newest-first, keeping condensed lines until the budget is
     # spent, then restore chronological (oldest→newest) order.
@@ -365,7 +447,7 @@ def run_agent_chat(cfg):
     _log(f"current task (latest user message): {task_text.rsplit('Current task: ', 1)[-1][:240]!r}")
 
     # Route: ask the model if this task needs HTTP tool use.
-    needs_agent = _route(task_text, agent_base_url, agent_api_key, agent_model_id)
+    needs_agent = _route(latest_user_text, agent_base_url, agent_api_key, agent_model_id)
 
     if not needs_agent:
         _log("router: plain chat (no HTTP needed)")
@@ -378,13 +460,20 @@ def run_agent_chat(cfg):
     _log("router: agent (HTTP tool use needed)")
     _emit({"type": "step", "text": "Planning HTTP request…"})
 
-    # Prepend explicit tool instructions so small models use http_request correctly
-    # and always terminate with final_answer() rather than looping forever.
+    # Prepend explicit tool instructions so small models pick the right tool, never
+    # fabricate URLs/responses, and always terminate with final_answer().
+    from datetime import datetime as _dt_now
+    now_str = _dt_now.now().astimezone().strftime("%A, %d %B %Y, %H:%M %Z")
     tool_hint = (
-        "You have ONE built-in function:\n"
-        "  `http_request(method, url, headers='', body='', username='', password='')`\n"
+        f"Current date/time: {now_str}.\n\n"
+        "You have THREE tools:\n"
+        "  1. http_request(method, url, headers='', body='', username='', password='') — "
+        "call a SPECIFIC known API/URL.\n"
+        "  2. web_search(query) — look up facts when you do NOT already have a real URL. "
+        "Returns a summary + source.\n"
+        "  3. get_current_datetime(timezone='') — current date/time (no HTTP needed).\n"
         "\n"
-        "RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
+        "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
         "\n"
         "BASIC AUTH — ALWAYS use username= and password=, NEVER construct headers manually:\n"
         "  response = http_request('GET', 'https://api.example.com/data',\n"
@@ -396,11 +485,18 @@ def run_agent_chat(cfg):
         "  response = http_request('GET', url, headers='{\"Authorization\": \"Bearer TOKEN\"}')\n"
         "  final_answer(response)\n"
         "\n"
+        "CHOOSING A TOOL:\n"
+        "- Date/time question -> get_current_datetime(); do NOT use http_request.\n"
+        "- 'find' / 'look up' / 'what is' / general knowledge -> web_search(query).\n"
+        "- A specific known API/URL was given -> http_request().\n"
+        "\n"
         "RULES:\n"
-        "- Pass response DIRECTLY to final_answer — do NOT split, parse, or index the string.\n"
-        "- If the response starts with 'HTTP 2' it SUCCEEDED — call final_answer immediately.\n"
-        "- If http_request returns 'Error:' or HTTP 4xx/5xx, try a different approach.\n"
-        "- Python's datetime module is available for date/time tasks (no HTTP needed).\n"
+        "- NEVER invent or guess a URL. If you have no real URL, use web_search() instead. "
+        "If nothing works, call final_answer explaining what you need — do NOT make up an answer.\n"
+        "- Only report what a tool ACTUALLY returned. Never fabricate a response, body, or status code.\n"
+        "- Pass an http_request response DIRECTLY to final_answer — do NOT split, parse, or index it.\n"
+        "- If a response starts with 'HTTP 2' it SUCCEEDED — call final_answer immediately.\n"
+        "- If a tool returns 'Error:' or HTTP 4xx/5xx, try a DIFFERENT approach, not the same URL.\n"
         "- Do NOT put final_answer outside the code block.\n\n"
     )
     task_with_hint = tool_hint + "Task: " + task_text
@@ -452,13 +548,57 @@ def run_agent_chat(cfg):
                 "Try a DIFFERENT URL or use Python's datetime/math/etc. module instead."
             )
         status_line = result.split("\n")[0][:150] if result else "no response"
-        # Append a success tag to 2xx responses so the model knows to stop and call final_answer.
-        if result and result.startswith("HTTP 2"):
+        # Detect HTML pages so the model stops trying to json.loads() a web page.
+        body_part = result.split("\n", 1)[1].lstrip().lower() if "\n" in result else ""
+        is_html = body_part.startswith("<!doctype html") or body_part.startswith("<html")
+        if is_html:
+            result = result + (
+                "\n[NOTE: This is an HTML web page, not JSON. Do NOT json.loads() it. "
+                "Use web_search() for facts, or request a JSON API endpoint instead.]"
+            )
+        # Append a success tag to 2xx JSON responses so the model stops and calls final_answer.
+        elif result and result.startswith("HTTP 2"):
             result = result + "\n[SUCCESS — call final_answer(response) now, do not parse or retry]"
         _emit({"type": "step", "text": f"HTTP {method.upper()} {url} → {status_line}"})
         _log(f"http_request {method.upper()} {url} → {result[:80]}")
         return result
 
+    @tool
+    def get_current_datetime(timezone: str = "") -> str:
+        """Return the current date and time. Use for any date/time question — no HTTP needed.
+
+        Args:
+            timezone: Optional IANA timezone name (e.g. 'Asia/Bangkok', 'UTC'). Empty = server local time.
+        """
+        from datetime import datetime as _dtl
+        try:
+            if timezone:
+                from zoneinfo import ZoneInfo
+                now = _dtl.now(ZoneInfo(timezone))
+            else:
+                now = _dtl.now().astimezone()
+        except Exception:  # noqa: BLE001
+            now = _dtl.now().astimezone()
+        out = now.strftime("%A, %d %B %Y, %H:%M:%S %Z")
+        _emit({"type": "step", "text": f"Current date/time → {out}"})
+        _log(f"get_current_datetime({timezone!r}) → {out}")
+        return out
+
+    @tool
+    def web_search(query: str) -> str:
+        """Search for factual or encyclopedic information using free no-key sources.
+
+        Use this INSTEAD of guessing a URL when the user asks to 'find' something or asks a
+        general-knowledge question. Returns a short summary and a source URL.
+
+        Args:
+            query: What to look up, e.g. 'capital of France' or 'productivity day-to-day method'.
+        """
+        _emit({"type": "step", "text": f"Searching the web → {query[:80]}"})
+        result = _web_search_impl(query)
+        _log(f"web_search {query[:60]!r} → {result[:80]}")
+        return result
+
     def step_callback(step_log):
         step_num = getattr(step_log, "step_number", "?")
 
@@ -525,7 +665,7 @@ def run_agent_chat(cfg):
             api_key=agent_api_key,
         )
         agent = CodeAgent(
-            tools=[http_request],
+            tools=[http_request, web_search, get_current_datetime],
             model=model,
             max_steps=max_steps,
             step_callbacks=[step_callback],

package/package.json

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