From eabbe470879f4a926421dc7e84fa20316d588805 Mon Sep 17 00:00:00 2001
From: kmbandy <kmbandy8807@gmail.com>
Date: Sun, 22 Mar 2026 09:11:08 -0400
Subject: [PATCH] =?UTF-8?q?chore:=20consolidate=20shortcuts=20=E2=80=94=20?=
 =?UTF-8?q?remove=20SHORTCUTS.md=20(moved=20to=20mad-lab-scripts)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Core fork modifications staged alongside: loop.py, litellm_provider.py,
schema.py, discord.py, commands.py, registry.py (suppressToolsParam,
XML tool extraction, SysmonTool, allow_bots, MCP auto-reconnect patches).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 SHORTCUTS.md                          | 79 ---------------------------
 nanobot/agent/loop.py                 | 61 ++++++++++++++++++---
 nanobot/agent/tools/registry.py       |  8 +++
 nanobot/channels/discord.py           |  7 +++
 nanobot/cli/commands.py               |  1 +
 nanobot/config/schema.py              |  1 +
 nanobot/providers/litellm_provider.py | 79 ++++++++++++++++++++++++++-
 7 files changed, 146 insertions(+), 90 deletions(-)
 delete mode 100644 SHORTCUTS.md

diff --git a/SHORTCUTS.md b/SHORTCUTS.md
deleted file mode 100644
index af1dc5f9974..00000000000
--- a/SHORTCUTS.md
+++ /dev/null
@@ -1,79 +0,0 @@
-# Discord Shortcuts
-
-All commands are handled by **eng-1** (OmniCoder-9B). Commands are processed
-before the LLM — instant returns, no tool calls, no context used.
-
----
-
-## Fleet / System
-
-| Command | Description |
-|---------|-------------|
-| `/help` | Show all available commands |
-| `!ping` | Bot liveness check — model name + uptime |
-| `!status` | Fleet GPU/RAM/agent status (all bots) |
-| `!tasks` | Pending pipeline tasks from ChromaDB |
-| `!models` | List all model files in `~/models/` |
-| `!mad-hot-swap <bot> <model>` | Swap running model on a bot and restart it. e.g. `!mad-hot-swap eng-1 qwen3.5-9b` |
-| `!restart <bot>` | Restart eng-1, eng-2, or arch-1 |
-| `/new` or `!reset` | Clear current session history |
-| `/stop` | Stop current running task |
-
----
-
-## Research / Web
-
-| Command | Description |
-|---------|-------------|
-| `!summarize <url>` | Fetch a webpage and summarize it |
-| `!wikipedia <subject>` | Wikipedia summary for any subject (REST API, falls back to search) |
-| `!gh <owner/repo>` | GitHub repo info + latest release. e.g. `!gh anthropics/claude-code` |
-| `!search <query>` | Web search, 5 results, then stops |
-| `!arxiv <query>` | arxiv search, 5 papers, then stops |
-| `!reddit <sub> <topic>` | Subreddit search, 5 posts, then stops |
-
----
-
-## Code / Dev
-
-| Command | Description |
-|---------|-------------|
-| `!diff` | Show nanobot commits since last upstream sync |
-| `!mad-code-summary <path>` | Summarize a file's purpose. Resolves against `~/mad-lab-mcp/` and `~/nanobot/` |
-| `!python <description>` | Generate a Python script or function |
-| `!explain <code/concept>` | Plain-English explanation |
-
----
-
-## Mad-Lab
-
-| Command | Description |
-|---------|-------------|
-| `!brief` | On-demand overnight summary (same as morning-brief cron) |
-| `!mem <query>` | Search ChromaDB knowledge base |
-| `!new-nanobot` | Interactive wizard — create a new bot config + systemd service files via Discord |
-| `!new-nanobot cancel` | Cancel an in-progress wizard |
-| `!remind <time> <msg>` | Set a reminder. e.g. `!remind 20m check arch-1` |
-
----
-
-## Sports / Entertainment
-
-| Command | Description |
-|---------|-------------|
-| `!united-latest` | Man Utd last result, next fixture (EST), PL standings (±2 teams), r/ManUtd talking points |
-
----
-
-## Cron Jobs
-
-These run automatically — no Discord command needed.
-
-| Script | Schedule | Description |
-|--------|----------|-------------|
-| `morning-brief` | Daily 8am EST | Overnight ChromaDB summary posted to Discord |
-| `fut-daily` | Daily 1:30pm EST | EA FC 26 / FUT content from fut.gg |
-| `run_scraper.py` | Daily midnight EST | arxiv, HackerNews, GitHub trending + releases scraped to ChromaDB |
-| `upstream-check-cron` | Monday 8am EST | Alert if nanobot upstream has new commits; warns on protected file changes |
-| `nightly-shutdown.sh` | Configurable | Nightly server shutdown |
-| `weekly-digest` | Configurable | Weekly ChromaDB digest |
diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.py
index 8d4eae04709..207e0475ef4 100644
--- a/nanobot/agent/loop.py
+++ b/nanobot/agent/loop.py
@@ -321,22 +321,68 @@ def _build_summarize_prompt(raw: str) -> str | None:
 
 
 async def _cmd_wikipedia(raw: str) -> str:
-    """Fetch a Wikipedia summary for a subject."""
+    """Fetch a Wikipedia summary for a subject. Tries local Kiwix first, falls back to Wikipedia REST API."""
     import httpx
+    import re
 
     idx = raw.lower().find("!wikipedia ")
     subject = raw[idx + len("!wikipedia "):].strip() if idx != -1 else raw.strip()
     if not subject:
         return "Usage: `!wikipedia <subject>`"
 
-    # Wikipedia REST API — returns clean summary JSON, no parsing needed
+    # --- Try local Kiwix first (offline, faster) ---
+    kiwix_url = "http://localhost:8091"
+    wiki_book = "wikipedia_en_all_maxi_2026-02"
+    try:
+        async with httpx.AsyncClient(timeout=5, follow_redirects=True) as client:
+            search_resp = await client.get(
+                f"{kiwix_url}/search",
+                params={"pattern": subject, "lang": "eng", "books": wiki_book},
+                headers={"User-Agent": "mad-lab-bot/1.0"},
+            )
+            if search_resp.status_code == 200:
+                from lxml import html as lxml_html
+                dom = lxml_html.fromstring(search_resp.text)
+                links = dom.xpath('//div[@class="results"]//a[@href]')
+                if links:
+                    href = links[0].get("href", "").strip()
+                    article_resp = await client.get(
+                        kiwix_url + href,
+                        headers={"User-Agent": "mad-lab-bot/1.0"},
+                    )
+                    if article_resp.status_code == 200:
+                        adom = lxml_html.fromstring(article_resp.text)
+                        # Extract page title
+                        page_title = "".join(adom.xpath('//h1//text()')).strip() or subject
+                        # Extract lead paragraphs (before first section header)
+                        paras = []
+                        for p in adom.xpath('//div[@id="mw-content-text"]//p[not(ancestor::table)]'):
+                            text = p.text_content().strip()
+                            # Skip short/empty paragraphs and citation-only lines
+                            text = re.sub(r'\[\d+\]', '', text).strip()
+                            if len(text) > 60:
+                                paras.append(text)
+                            if sum(len(x) for x in paras) >= 1000:
+                                break
+                        if paras:
+                            extract = " ".join(paras)[:1200]
+                            if len(" ".join(paras)) > 1200:
+                                extract += "…"
+                            kiwix_article_url = kiwix_url + href
+                            lines = [f"📖 **{page_title}** _(via local Kiwix)_", ""]
+                            lines.append(extract)
+                            lines.append(f"\n<{kiwix_article_url}>")
+                            return "\n".join(lines)
+    except Exception:
+        pass  # Fall through to Wikipedia REST API
+
+    # --- Fallback: Wikipedia REST API ---
     title = subject.strip().replace(" ", "_")
     url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{title}"
     try:
         async with httpx.AsyncClient(timeout=10, follow_redirects=True) as client:
             resp = await client.get(url, headers={"User-Agent": "mad-lab-bot/1.0"})
             if resp.status_code == 404:
-                # Try search API to find closest match
                 search_resp = await client.get(
                     "https://en.wikipedia.org/w/api.php",
                     params={
@@ -361,17 +407,16 @@ async def _cmd_wikipedia(raw: str) -> str:
     except Exception as e:
         return f"❌ Wikipedia fetch failed: {e}"
 
-    page_title   = data.get("title", subject)
-    extract      = data.get("extract", "")
-    wiki_url     = data.get("content_urls", {}).get("desktop", {}).get("page", "")
-    description  = data.get("description", "")
+    page_title  = data.get("title", subject)
+    extract     = data.get("extract", "")
+    wiki_url    = data.get("content_urls", {}).get("desktop", {}).get("page", "")
+    description = data.get("description", "")
 
     lines = [f"📖 **{page_title}**"]
     if description:
         lines.append(f"_{description}_")
     lines.append("")
     if extract:
-        # Cap at ~1200 chars so it fits cleanly in Discord
         lines.append(extract[:1200] + ("…" if len(extract) > 1200 else ""))
     if wiki_url:
         lines.append(f"\n<{wiki_url}>")
diff --git a/nanobot/agent/tools/registry.py b/nanobot/agent/tools/registry.py
index 896491f4fef..276dbed2995 100644
--- a/nanobot/agent/tools/registry.py
+++ b/nanobot/agent/tools/registry.py
@@ -40,6 +40,14 @@ async def execute(self, name: str, params: dict[str, Any]) -> str:
         _HINT = "\n\n[Analyze the error above and try a different approach.]"
 
         tool = self._tools.get(name)
+        if not tool:
+            # Models often output underscores where registered names use hyphens.
+            # Try normalizing hyphens→underscores in registered names and retry.
+            normalized = name.replace("-", "_")
+            tool = next(
+                (t for k, t in self._tools.items() if k.replace("-", "_") == normalized),
+                None,
+            )
         if not tool:
             return f"Error: Tool '{name}' not found. Available: {', '.join(self.tool_names)}"
 
diff --git a/nanobot/channels/discord.py b/nanobot/channels/discord.py
index dff2e6ab4e1..55bc14362f6 100644
--- a/nanobot/channels/discord.py
+++ b/nanobot/channels/discord.py
@@ -75,6 +75,13 @@ async def start(self) -> None:
                 break
             except Exception as e:
                 logger.warning("Discord gateway error: {}", e)
+                # Non-recoverable close codes — retrying will never help.
+                err_str = str(e)
+                fatal_codes = ("4004", "4010", "4011", "4012", "4013", "4014")
+                if any(code in err_str for code in fatal_codes):
+                    logger.error("Discord fatal error ({}), stopping reconnect loop.", err_str[:80])
+                    self._running = False
+                    break
                 if self._running:
                     logger.info("Reconnecting to Discord gateway in 5 seconds...")
                     await asyncio.sleep(5)
diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.py
index 24a9fc3cc7b..b47aca56032 100644
--- a/nanobot/cli/commands.py
+++ b/nanobot/cli/commands.py
@@ -438,6 +438,7 @@ def _make_provider(config: Config):
             extra_headers=p.extra_headers if p else None,
             provider_name=provider_name,
             suppress_tools_param=p.suppress_tools_param if p else False,
+            request_timeout=p.request_timeout if p else None,
         )
 
     defaults = config.agents.defaults
diff --git a/nanobot/config/schema.py b/nanobot/config/schema.py
index e32fcb9c28b..6848d1715b0 100644
--- a/nanobot/config/schema.py
+++ b/nanobot/config/schema.py
@@ -219,6 +219,7 @@ class ProviderConfig(Base):
     api_base: str | None = None
     extra_headers: dict[str, str] | None = None  # Custom headers (e.g. APP-Code for AiHubMix)
     suppress_tools_param: bool = False  # Don't send tools in API call; rely on text extraction
+    request_timeout: int | None = None  # LLM request timeout in seconds (None = litellm default 600s)
 
 
 class ProvidersConfig(Base):
diff --git a/nanobot/providers/litellm_provider.py b/nanobot/providers/litellm_provider.py
index dcc580c9ce0..87936377061 100644
--- a/nanobot/providers/litellm_provider.py
+++ b/nanobot/providers/litellm_provider.py
@@ -41,11 +41,13 @@ def __init__(
         extra_headers: dict[str, str] | None = None,
         provider_name: str | None = None,
         suppress_tools_param: bool = False,
+        request_timeout: int | None = None,
     ):
         super().__init__(api_key, api_base)
         self.default_model = default_model
         self.extra_headers = extra_headers or {}
         self.suppress_tools_param = suppress_tools_param
+        self.request_timeout = request_timeout
 
         # Detect gateway / local deployment.
         # provider_name (from config key) is the primary signal;
@@ -279,6 +281,9 @@ async def chat(
             kwargs["tools"] = tools
             kwargs["tool_choice"] = tool_choice or "auto"
 
+        if self.request_timeout is not None:
+            kwargs["timeout"] = self.request_timeout
+
         try:
             response = await acompletion(**kwargs)
             return self._parse_response(response)
@@ -318,6 +323,8 @@ def _parse_response(self, response: Any) -> LLMResponse:
             args = tc.function.arguments
             if isinstance(args, str):
                 args = json_repair.loads(args)
+            if not isinstance(args, dict):
+                args = {}
 
             provider_specific_fields = getattr(tc, "provider_specific_fields", None) or None
             function_provider_specific_fields = (
@@ -341,8 +348,14 @@ def _parse_response(self, response: Any) -> LLMResponse:
 
         # Fallback: some models (e.g. Qwen via Ollama/vLLM) embed tool-call JSON
         # in the text content instead of the structured tool_calls field.
-        if tool_calls is None and content:
-            tool_calls, content = LiteLLMProvider._extract_text_tool_calls(content)
+        # Strip <think>...</think> blocks first — thinking models (e.g. Qwen3 with
+        # thinking=1) embed reasoning in content; tool calls appear after the block.
+        if not tool_calls and content:
+            import re as _re
+            stripped = _re.sub(r"<think>.*?</think>", "", content, flags=_re.DOTALL).strip()
+            tool_calls, extracted_content = LiteLLMProvider._extract_text_tool_calls(stripped)
+            if tool_calls:
+                content = extracted_content
 
         # Strip EOS/EOT tokens that some models (e.g. Ministral via llama.cpp) leak
         # into response content. If stored in history they break Jinja chat templating
@@ -374,7 +387,67 @@ def _extract_text_tool_calls(content: str) -> tuple[list[ToolCallRequest], str |
         """
         import re
 
-        # Try XML format: <tool_call><function=name><parameter=key>value</parameter>...</function></tool_call>
+        # Try Qwen3 format: <tool_call>{"name": "...", "arguments": {...}}</tool_call>
+        qwen_calls = []
+        for qwen_match in re.finditer(r"<tool_call>(.*?)</tool_call>", content, re.DOTALL):
+            try:
+                obj = json_repair.loads(qwen_match.group(1).strip())
+                if isinstance(obj, dict) and isinstance(obj.get("name"), str) and isinstance(obj.get("arguments"), dict):
+                    qwen_calls.append(ToolCallRequest(id=_short_tool_id(), name=obj["name"], arguments=obj["arguments"]))
+            except Exception:
+                pass
+        if qwen_calls:
+            first = re.search(r"<tool_call>", content)
+            preamble = (content[:first.start()].strip() if first else None) or None
+            logger.info("_parse_response: extracted {} Qwen3-embedded tool call(s): {}",
+                        len(qwen_calls), [c.name for c in qwen_calls])
+            return qwen_calls, preamble
+
+        # Try [TOOL_CALLS]name[ARGS]{json} format (Nemotron/Orchestrator models)
+        # Don't regex-match the JSON body — find the opening { and let json_repair
+        # consume as much as it needs. This handles large result strings with } inside.
+        tc_calls = []
+        for tc_match in re.finditer(r"\[TOOL_CALLS\]([\w_\-]+)\[ARGS\](\{)", content, re.DOTALL):
+            try:
+                json_start = tc_match.start(2)
+                args = json_repair.loads(content[json_start:])
+                if not isinstance(args, dict):
+                    args = {}
+                tc_calls.append(ToolCallRequest(id=_short_tool_id(), name=tc_match.group(1).strip(), arguments=args))
+            except Exception:
+                pass
+        if tc_calls:
+            first = re.search(r"\[TOOL_CALLS\]", content)
+            preamble = (content[:first.start()].strip() if first else None) or None
+            logger.info("_parse_response: extracted {} [TOOL_CALLS]-format tool call(s): {}",
+                        len(tc_calls), [c.name for c in tc_calls])
+            return tc_calls, preamble
+
+        # Try Python code-block format: ```python\ntool_name(arg="value")\n```
+        import ast as _ast
+        py_block_match = re.search(r"```(?:python)?\s*\n?([\w_]+\(.*?\))\s*\n?```", content, re.DOTALL)
+        if py_block_match:
+            call_src = py_block_match.group(1).strip()
+            fn_match = re.match(r"([\w_]+)\((.*)\)$", call_src, re.DOTALL)
+            if fn_match:
+                fn_name = fn_match.group(1)
+                args_src = fn_match.group(2).strip()
+                try:
+                    # Parse as keyword args only: key="val", key2=123, ...
+                    dummy = f"_f({args_src})"
+                    tree = _ast.parse(dummy, mode="eval")
+                    arguments = {}
+                    for kw in tree.body.keywords:  # type: ignore[attr-defined]
+                        if kw.arg:
+                            arguments[kw.arg] = _ast.literal_eval(kw.value)
+                    py_call = ToolCallRequest(id=_short_tool_id(), name=fn_name, arguments=arguments)
+                    preamble = content[:py_block_match.start()].strip() or None
+                    logger.info("_parse_response: extracted Python code-block tool call: {}", fn_name)
+                    return [py_call], preamble
+                except Exception:
+                    pass
+
+        # Try legacy XML format: <tool_call><function=name><parameter=key>value</parameter>...</function></tool_call>
         # Model may omit closing </function> tag, so match up to </tool_call> or end of string.
         xml_match = re.search(r"<tool_call>", content)
         if xml_match: