Add the MCP server panel, and pin the MCP deps it relies on

The tool servers sleep when idle, and a cold one made the agent look broken with no way
to tell why. The panel opens as a floating overlay beside the model controls — an
accordion pushed the whole page down — and every row carries its own refresh, so waking
one cold server never re-hits the healthy ones. A dot beside the label aggregates status
so a down server is visible without opening anything. Rows paint "Checking…" before the
requests start: a cold server can take ~10s, and without that the header refresh looked
like it did nothing.

Refreshes run with queue=False. The app serializes queued work at concurrency 1, so a
queued refresh would hold the only slot and stall every visitor's chat turn behind it.

fastmcp-slim and mcp are pinned in the same commit because this push triggers a rebuild,
and an unpinned rebuild is what just took MIO down: fastmcp-slim 4.0.0 dropped the
mcp<2.0 cap, pip took mcp 2.x, and 2.x renamed ToolsCapability.listChanged, which
pydantic-ai 2.16.0 still reads. Shipping the panel without the pins would have broken
every query on arrival.

app.py

@@ -19,6 +19,8 @@ Run locally:
 from __future__ import annotations
 
 import hashlib
+import threading
+import json
 import os
 import re
 import time
@@ -129,6 +131,256 @@ def _probe_mcp_servers() -> tuple[list, set[str]]:
 
 MCP_TOOLSETS, MCP_TOOLS_AVAILABLE = _probe_mcp_servers()
 
+# The JSON-RPC handshake the agent itself sends, so a probe sees exactly what the
+# agent would see rather than a bare reachability guess (a 401 or 500 is not "up").
+_MCP_INIT = {"jsonrpc": "2.0", "id": 1, "method": "initialize",
+             "params": {"protocolVersion": "2025-03-26", "capabilities": {},
+                        "clientInfo": {"name": "akd-probe", "version": "0"}}}
+
+
+# ── Tool warm-up (manual refresh) ───────────────────────────────────────────────
+# The hosted MCP servers are FastMCP instances that sleep when idle. On a cold
+# Space the first query races their wake-up: the startup probe marks them down,
+# build_toolsets() skips them, and the agent answers with only the tools that
+# happened to be awake — which looks like the agent "not working properly" rather
+# than like an outage. This is the akd-labs services/mcp_warmup.py approach: send
+# the real JSON-RPC `initialize` each server would receive from the agent, so we
+# see the same failure the agent would (auth rejected, cold-start timeout, broken
+# JSON-RPC handler), and report it per server instead of a bare reachable/not.
+_WARMUP_TIMEOUT = float(os.environ.get("MCP_WARMUP_TIMEOUT", "20"))
+# The button is public, so it needs a bound. Without one, every click fans out a POST
+# per server to NASA's FastMCP instances, and N visitors clicking repeatedly becomes an
+# amplifier pointed at someone else's infrastructure. Two guards: a single-flight lock
+# so concurrent clicks share ONE warm-up instead of each starting their own, and a
+# cooldown so clicks inside the window return the last result (labelled with its age)
+# rather than re-probing. Server state is shared by every visitor anyway — they all use
+# the same endpoints — so a shared, briefly-cached answer is the honest one.
+_WARMUP_COOLDOWN = float(os.environ.get("MCP_WARMUP_COOLDOWN", "30"))
+# Per-server, not global: warming every server on each click hammered endpoints that
+# were already healthy. Each server owns its cooldown and its own single-flight lock,
+# so refreshing one never touches the others and simultaneous clicks on the SAME server
+# collapse into one request.
+_WARMUP_STATE: dict = {}          # server name -> {"t": float, "result": dict}
+_WARMUP_LOCKS: dict = {}          # server name -> threading.Lock
+_WARMUP_LOCKS_GUARD = threading.Lock()
+
+
+def _server_lock(name: str) -> threading.Lock:
+    with _WARMUP_LOCKS_GUARD:
+        return _WARMUP_LOCKS.setdefault(name, threading.Lock())
+
+
+def _parse_jsonrpc(text: str, content_type: str):
+    """A JSON-RPC object out of either a plain JSON body or an SSE `data:` frame."""
+    body = (text or "").strip()
+    if "text/event-stream" in (content_type or ""):
+        for line in body.splitlines():
+            line = line.strip()
+            if line.startswith("data:"):
+                try:
+                    obj = json.loads(line[5:].strip())
+                except Exception:
+                    continue
+                if isinstance(obj, dict):
+                    return obj
+        return None
+    try:
+        obj = json.loads(body)
+    except Exception:
+        return None
+    return obj if isinstance(obj, dict) else None
+
+
+def _warmup_one(client, name: str, url: str, headers: dict, timeout: float) -> dict:
+    """One `initialize` round-trip, classified the way the agent would experience it."""
+    import time as _time
+
+    started = _time.perf_counter()
+    try:
+        r = client.post(url, json=_MCP_INIT, headers=headers, timeout=timeout,
+                        follow_redirects=True)
+        ms = int((_time.perf_counter() - started) * 1000)
+        if r.status_code in (401, 403):
+            return {"name": name, "status": "down", "ms": ms, "http": r.status_code,
+                    "detail": "auth rejected"}
+        if r.status_code >= 400:
+            # detail stays empty: the row already renders "· HTTP {code}" from `http`,
+            # and duplicating it read as "Unavailable · HTTP 404 · HTTP 404".
+            return {"name": name, "status": "down", "ms": ms, "http": r.status_code,
+                    "detail": ""}
+        rpc = _parse_jsonrpc(r.text, r.headers.get("content-type", ""))
+        if rpc is None:
+            return {"name": name, "status": "down", "ms": ms, "http": r.status_code,
+                    "detail": "not an MCP endpoint"}
+        if isinstance(rpc.get("error"), dict):
+            return {"name": name, "status": "down", "ms": ms, "http": r.status_code,
+                    "detail": rpc["error"].get("message") or "MCP error"}
+        if "result" in rpc:
+            return {"name": name, "status": "up", "ms": ms, "http": r.status_code,
+                    "detail": ""}
+        return {"name": name, "status": "down", "ms": ms, "http": r.status_code,
+                "detail": "no JSON-RPC result"}
+    except Exception as exc:
+        ms = int((_time.perf_counter() - started) * 1000)
+        kind = "still waking (timed out)" if "Timeout" in type(exc).__name__ else type(exc).__name__
+        return {"name": name, "status": "down", "ms": ms, "http": None, "detail": kind}
+
+def http_server_targets() -> dict:
+    """{server name: (url, headers)} — None where the token is missing. Built from
+    MCP_SERVER_SPECS so the panel always mirrors the servers the agent actually uses."""
+    out: dict = {}
+    for name, url_env, url_default, key_env, _allow in MCP_SERVER_SPECS:
+        url = _env(url_env) or url_default
+        key = _env(key_env)
+        headers = {"content-type": "application/json",
+                   "accept": "application/json, text/event-stream"}
+        if not key:
+            out[name] = None
+            continue
+        headers["Authorization"] = f"Bearer {key}"
+        out[name] = (url, headers)
+    return out
+
+
+SERVER_NAMES = list(http_server_targets().keys())
+
+
+def _publish_state() -> None:
+    """No-op here, deliberately.
+
+    MIO reseeds a 120s probe cache at this point so a just-woken server is picked up by
+    the next query. This agent resolves its toolsets once at startup (see
+    _probe_mcp_servers), so there is no cache to reseed: the panel is diagnostic, and
+    waking a cold server warms it for subsequent calls without changing which tools this
+    process already loaded. Restart the Space to pick up a server that was down at boot.
+    """
+    return
+
+
+def warmup_server(name: str, timeout: float | None = None) -> tuple[dict, int]:
+    """Warm ONE server. Returns (result, age_seconds); age > 0 means the cooldown
+    served the previous result instead of re-probing.
+
+    Cooldown + single-flight are per server, so a click on `geoui` never sends a
+    request to `cmr`, and two people clicking `geoui` together produce one request.
+    """
+    import httpx
+
+    target = http_server_targets().get(name, None)
+    if target is None:
+        res = {"name": name, "status": "skipped", "ms": 0, "http": None,
+               "detail": "no token configured"}
+        _WARMUP_STATE[name] = {"t": time.monotonic(), "result": res}
+        return res, 0
+
+    st = _WARMUP_STATE.get(name)
+    now = time.monotonic()
+    if st and st.get("result") and now - st["t"] < _WARMUP_COOLDOWN:
+        return st["result"], int(now - st["t"])
+
+    with _server_lock(name):
+        st = _WARMUP_STATE.get(name)          # another click may have just done it
+        now = time.monotonic()
+        if st and st.get("result") and now - st["t"] < _WARMUP_COOLDOWN:
+            return st["result"], int(now - st["t"])
+        url, headers = target
+        timeout = timeout or _WARMUP_TIMEOUT
+        with httpx.Client() as client:
+            res = _warmup_one(client, name, url, headers, timeout)
+            # A timeout means it was probably asleep and this request booted it, so the
+            # retry is the one that finds it awake — that IS the point of the button.
+            if res["status"] == "down" and "waking" in res["detail"]:
+                res = _warmup_one(client, name, url, headers, timeout)
+                if res["status"] == "up":
+                    res["detail"] = "woken"
+        _WARMUP_STATE[name] = {"t": time.monotonic(), "result": res}
+        _publish_state()
+        return res, 0
+
+
+def warmup_pending(timeout: float | None = None) -> list[tuple[dict, int]]:
+    """Warm only servers not currently known-good — never the healthy ones.
+
+    This is what the bulk control uses, so a click costs one request per *problem*
+    server instead of one per server. With everything up it costs nothing.
+    """
+    import concurrent.futures as _cf
+
+    pending = [n for n in SERVER_NAMES
+               if (_WARMUP_STATE.get(n, {}).get("result") or {}).get("status") != "up"]
+    if not pending:
+        return []
+    with _cf.ThreadPoolExecutor(len(pending)) as ex:
+        return list(ex.map(lambda n: warmup_server(n, timeout), pending))
+
+def _server_row_html(name: str, res: dict | None = None, age: int = 0) -> str:
+    """One popover row: status dot, server name, and a detail line in the akd-labs
+    wording (`Available · HTTP 200 · 352ms`). Colour lives in the dot, not the row
+    background — Gradio 6's Svelte styling overrides even an inline `!important`
+    background on its own controls, but a plain <span> is untouched by that."""
+    state = (res or {}).get("status")
+    dot = {"up": "mdot-up", "down": "mdot-down", "skipped": "mdot-skip"}.get(state, "mdot-idle")
+    if res is None:
+        detail = "Not checked yet"
+    elif state == "up":
+        bits = ["Available"]
+        if res.get("http") is not None:
+            bits.append(f"HTTP {res['http']}")
+        bits.append(f"{res['ms']}ms")
+        if age:
+            bits.append(f"checked {age}s ago")
+        detail = " · ".join(bits)
+    elif state == "skipped":
+        detail = res.get("detail") or "Skipped"
+    else:
+        bits = ["Unavailable"]
+        if res.get("http") is not None:
+            bits.append(f"HTTP {res['http']}")
+        if res.get("detail"):
+            bits.append(res["detail"])
+        detail = " · ".join(bits)
+    return (f'<div class="mrow"><span class="mdot {dot}"></span>'
+            f'<span class="mtext"><span class="mname">{name}</span>'
+            f'<span class="mstat">{detail}</span></span></div>')
+
+
+def _checking_html(name: str) -> str:
+    return (f'<div class="mrow"><span class="mdot mdot-idle"></span>'
+            f'<span class="mtext"><span class="mname">{name}</span>'
+            f'<span class="mstat">Checking…</span></span></div>')
+
+
+def _label_html() -> str:
+    """Field label with an aggregate status dot, so a glance tells you whether anything
+    is down without opening the panel. Grey until something has been checked — claiming
+    green before we have probed would be a guess. The tooltip carries the counts."""
+    results = [(_WARMUP_STATE.get(n) or {}).get("result") for n in SERVER_NAMES]
+    checked = [r for r in results if r]
+    if not SERVER_NAMES:
+        cls, tip = "agg-idle", "No remote tool servers configured"
+    elif not checked:
+        cls, tip = "agg-idle", f"{len(SERVER_NAMES)} servers · not checked yet"
+    else:
+        up = sum(1 for r in checked if r["status"] == "up")
+        bad = len(checked) - up
+        unchecked = len(SERVER_NAMES) - len(checked)
+        cls = "agg-down" if bad else ("agg-idle" if unchecked else "agg-up")
+        bits = ([f"{up} up"] if up else []) + ([f"{bad} unavailable"] if bad else []) \
+            + ([f"{unchecked} unchecked"] if unchecked else [])
+        tip = " · ".join(bits)
+    return (f'<span class="mcplabel">🛠️ MCP servers'
+            f'<span class="aggdot {cls}" title="{tip}"></span></span>'
+            f'<span class="mcpinfo-line">Status &amp; refresh.</span>')
+
+
+def _tools_face() -> str:
+    """Static face for the trigger. It deliberately does NOT carry the up/unavailable
+    counts: that string wrapped to two lines and stretched the field out of line with
+    its neighbours, and the panel behind it already reports per-server state."""
+    n = len(SERVER_NAMES)
+    return f"{n} server{'s' if n != 1 else ''}" if n else "none configured"
+
+
 # ── AKD Guardrails (service-relayed: gliguard on input, risk_agent on output) ──
 # All guard logic lives server-side in the NASA-IMPACT/akd-guardrails service —
 # this app only relays verdicts, attached the pydantic-ai v2 way as harness
@@ -1249,6 +1501,118 @@ footer { display: none !important; }
   background: transparent !important; border: none !important; padding: 0 !important;
   color: #14162a !important; font-size: 12.5px !important; line-height: 1.7 !important;
 }
+
+/* MCP server popover — an OVERLAY, not an accordion: expanding a panel pushed the
+   whole page down, so this is absolutely positioned and floats above the content, with
+   a refresh icon on every row (mirrors the akd-labs MCP status popover). */
+/* #keyrow bottom-aligns its children, and this column is shorter than the native
+   blocks (the key field's info wraps to two lines), so its label sat ~44px below the
+   others. Stretch to the row height and push label to the top / field to the bottom,
+   which lines up BOTH edges with the native controls. */
+#toolscol { position: relative !important; gap: 0 !important;
+            align-self: stretch !important; justify-content: space-between !important;
+            /* native blocks carry padding:10px 12px — without it the label sat 10px
+               high and the field 12px low against its neighbours */
+            padding: 10px 0 12px !important; }
+#mcplabelwrap { flex: 0 0 auto !important; }
+/* label + info line, matching the Model/Effort blocks exactly */
+#mcplabelwrap, #mcplabelwrap .block { background: transparent !important; border: none !important;
+                                      padding: 0 !important; min-height: 0 !important; }
+.mcplabel { display: flex; align-items: center; gap: 7px; color: #14162a;
+            font-weight: 600; font-size: 14.5px; font-family: 'IBM Plex Sans', sans-serif;
+            margin-bottom: 2px; }
+/* aggregate dot: green when every checked server is up, red as soon as one is down,
+   grey while anything is still unchecked — never green on an assumption */
+.aggdot { width: 9px; height: 9px; border-radius: 50%; flex-shrink: 0; }
+.aggdot.agg-up   { background: #10b981; box-shadow: 0 0 0 3px rgba(16,185,129,.16); }
+.aggdot.agg-down { background: #ef4444; box-shadow: 0 0 0 3px rgba(239,68,68,.16); }
+.aggdot.agg-idle { background: #c9cbd8; }
+.mcpinfo-line { display: block; color: #8a8fa6; font-size: 12.5px;
+                font-family: 'IBM Plex Sans', sans-serif; margin-bottom: 6px; }
+/* the trigger IS the field: same fill, border, radius and height as the selects */
+#mcptrigger {
+  background: #f4f3ef !important; border: 1px solid rgba(20,22,40,0.14) !important;
+  border-radius: 10px !important; min-height: 42px !important; height: 42px !important;
+  color: #14162a !important; font-family: 'IBM Plex Mono', monospace !important;
+  /* 400, not Gradio's button default of 600 — the native select values are regular */
+  font-size: 14px !important; font-weight: 400 !important;
+  text-align: left !important; justify-content: flex-start !important;
+  padding: 8px 40px 8px 12px !important; box-shadow: none !important; width: 100% !important;
+  position: relative !important;
+}
+/* the caret is Gradio's own dropdown-arrow SVG (20x20, path M5 8l4 4 4-4z, inset 21px)
+   inlined as a data URI — a "▾" text glyph rendered smaller and lighter than the real
+   selects beside it */
+#mcptrigger::after {
+  content: ""; position: absolute; right: 21px; top: 50%; transform: translateY(-50%);
+  width: 20px; height: 20px; pointer-events: none;
+  background: currentColor;
+  -webkit-mask: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 18 18'><path d='M5 8l4 4 4-4z'/></svg>") center/100% no-repeat;
+  mask: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 18 18'><path d='M5 8l4 4 4-4z'/></svg>") center/100% no-repeat;
+}
+#mcptrigger:hover { filter: brightness(0.99); }
+#mcppanel {
+  position: absolute !important; top: calc(100% + 6px); right: 0; z-index: 60;
+  width: 430px; max-width: 92vw; background: #fff !important;
+  border: 1px solid rgba(20,22,40,.12) !important; border-radius: 12px !important;
+  box-shadow: 0 12px 32px rgba(20,22,40,.16) !important;
+  padding: 0 !important; gap: 0 !important; max-height: 340px; overflow-y: auto;
+}
+#mcphdr {
+  gap: 6px !important; align-items: center !important;
+  border-bottom: 1px solid rgba(20,22,40,.10) !important;
+  padding: 9px 12px !important; margin: 0 !important; position: sticky; top: 0;
+  background: #fff; z-index: 2;
+}
+.mcptitle { font-family: 'IBM Plex Sans', sans-serif; font-size: 13.5px;
+            font-weight: 600; color: #14162a; }
+#mcprefreshall, #mcpclose {
+  font-size: 19px !important; line-height: 1 !important; color: #565b73 !important;
+  background: transparent !important; border: none !important; box-shadow: none !important;
+  padding: 6px 9px !important; min-height: 0 !important; height: auto !important;
+  border-radius: 8px !important; flex: 0 0 auto !important; width: max-content !important;
+}
+#mcprefreshall:hover, #mcpclose:hover { color: #14162a !important; background: #f2f2f6 !important; }
+.mcprow { gap: 6px !important; align-items: center !important; margin: 0 !important;
+          padding: 2px 12px !important; }
+.mcprow:hover { background: #f7f7fb; }
+/* Gradio stamps `min-width: min(320px, 100%)` inline on every block, which in a 430px
+   popover forced the refresh icon onto its own line. Zero the floor and forbid wrapping
+   so the icon sits to the right of its server, as in the reference. */
+.mcprow, #mcphdr { flex-wrap: nowrap !important; }
+.mcpinfo, #mcphdrtitle { flex: 1 1 auto !important; min-width: 0 !important; }
+.mcpinfo, .mcpinfo .block { background: transparent !important; border: none !important;
+                            padding: 0 !important; min-height: 0 !important; }
+.mrow { display: flex; align-items: flex-start; gap: 10px; padding: 8px 0; }
+.mdot { width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; margin-top: 5px; }
+.mdot-up { background: #10b981; }
+.mdot-down { background: #ef4444; }
+.mdot-skip { background: #9aa0b4; }
+.mdot-idle { background: #c9cbd8; }
+.mtext { display: flex; flex-direction: column; line-height: 1.4; }
+.mname { font-family: 'IBM Plex Sans', sans-serif; font-size: 13.5px; font-weight: 600;
+         color: #14162a; }
+.mstat { font-family: 'IBM Plex Sans', sans-serif; font-size: 12px; color: #8a8fa6; }
+/* the per-row refresh icon, right-aligned like the reference */
+.mcprowbtn {
+  font-size: 19px !important; line-height: 1 !important; color: #565b73 !important;
+  background: transparent !important; border: none !important; box-shadow: none !important;
+  padding: 8px 10px !important; min-height: 34px !important; height: auto !important;
+  border-radius: 8px !important; flex: 0 0 auto !important; width: max-content !important;
+}
+.mcprowbtn:hover { color: #3d33ab !important; background: #efeefb !important; }
+/* the inline min-width Gradio sets on buttons would otherwise widen these icons */
+.mcprowbtn, #mcprefreshall, #mcpclose { min-width: 0 !important; }
+#toolstatus { flex: 0 0 auto !important; }
+#toolstatus, #toolstatus .block { background: transparent !important; border: none !important;
+                                   padding: 0 !important; min-height: 0 !important; }
+#toolstatus .tsum, #toolstatus .tmuted, #toolstatus .tbad {
+  font-family: 'IBM Plex Mono', monospace; font-size: 11.5px;
+}
+#toolstatus .tsum { color: #0b7c45; }
+#toolstatus .tbad { color: #b02a2a; }
+#toolstatus .tmuted { color: #8a8fa6; }
+
 """
 
 
@@ -1382,6 +1746,28 @@ with gr.Blocks(title="Code Search Agent") as demo:
                 info="Speed vs. depth.",
                 scale=1, min_width=180,
             )
+            # Cold-start escape hatch, styled as a field so it reads like the Model and
+            # Effort selects beside it. The panel it opens is a floating overlay rather
+            # than an accordion, which pushed the whole page down; every row carries its
+            # own refresh so waking one cold server never re-hits the healthy ones.
+            with gr.Column(scale=1, min_width=150, elem_id="toolscol"):
+                tools_label = gr.HTML(_label_html(), elem_id="mcplabelwrap")
+                tools_trigger = gr.Button(_tools_face(), elem_id="mcptrigger")
+                with gr.Column(elem_id="mcppanel", visible=False) as tools_panel:
+                    with gr.Row(elem_id="mcphdr"):
+                        gr.HTML('<span class="mcptitle">MCP servers</span>',
+                                elem_id="mcphdrtitle")
+                        refresh_all = gr.Button("⟳", size="sm", scale=0, min_width=0,
+                                                elem_id="mcprefreshall")
+                        close_panel = gr.Button("✕", size="sm", scale=0, min_width=0,
+                                                elem_id="mcpclose")
+                    tool_rows: dict = {}
+                    for _n in SERVER_NAMES:
+                        with gr.Row(elem_classes="mcprow"):
+                            _info = gr.HTML(_server_row_html(_n), elem_classes="mcpinfo")
+                            _btn = gr.Button("⟳", size="sm", scale=0, min_width=0,
+                                             elem_classes="mcprowbtn")
+                        tool_rows[_n] = (_info, _btn)
 
     with gr.Column(elem_id="chatcard"):
         chatbot = gr.Chatbot(
@@ -1430,6 +1816,56 @@ with gr.Blocks(title="Code Search Agent") as demo:
 
     # Submit flow: add user bubble + clear box, then stream the agent's reply.
     outputs = [chatbot, run_context]
+    panel_open = gr.State(False)
+
+    def _toggle_panel(is_open: bool):
+        return gr.update(visible=not is_open), (not is_open)
+
+    def _refresh_one(name: str):
+        """Refresh exactly one server: its own row and the status light, nothing else."""
+        res, age = warmup_server(name)
+        return _server_row_html(name, res, age), _label_html()
+
+    def _refresh_all():
+        """Header refresh — only servers that aren't ready, so with everything up it
+        sends nothing."""
+        warmup_pending()
+        rows = [_server_row_html(n, (_WARMUP_STATE.get(n) or {}).get("result"))
+                for n in SERVER_NAMES]
+        return [*rows, _label_html()]
+
+    def _mark_checking():
+        """Paint "Checking…" on every row this pass will actually contact, BEFORE the
+        requests start: a cold server can take ~10s, and without this the header refresh
+        looked broken. Rows already up are left alone — they aren't being re-hit."""
+        out = []
+        for n in SERVER_NAMES:
+            res = (_WARMUP_STATE.get(n) or {}).get("result")
+            out.append(_server_row_html(n, res) if (res or {}).get("status") == "up"
+                       else _checking_html(n))
+        return out
+
+    # queue=False is load-bearing: demo.queue(default_concurrency_limit=1) serializes
+    # queued work, so a queued refresh would hold the single slot and stall every
+    # visitor's chat turn behind it. show_progress="hidden" keeps Gradio's unanchored
+    # spinner off the card; each row shows its own "Checking…" state instead.
+    tools_trigger.click(_toggle_panel, panel_open, [tools_panel, panel_open],
+                        queue=False, show_progress="hidden")
+    close_panel.click(lambda: (gr.update(visible=False), False), None,
+                      [tools_panel, panel_open], queue=False, show_progress="hidden")
+
+    for _name, (_info, _btn) in tool_rows.items():
+        _btn.click(lambda n=_name: _checking_html(n), None, _info,
+                   queue=False, show_progress="hidden").then(
+            lambda n=_name: _refresh_one(n), None, [_info, tools_label],
+            queue=False, show_progress="hidden")
+
+    refresh_all.click(
+        _mark_checking, None, [i for i, _ in tool_rows.values()],
+        queue=False, show_progress="hidden",
+    ).then(_refresh_all, None, [*(i for i, _ in tool_rows.values()), tools_label],
+           queue=False, show_progress="hidden")
+
     send.click(_user_submit, [msg, chatbot], [msg, chatbot], queue=False).then(
         _bot_respond, [chatbot, api_key, model_dd, effort_dd, run_context], outputs
     )

requirements.txt

@@ -1,5 +1,13 @@
 gradio==6.19.0
 pydantic-ai==2.16.0
+# fastmcp-slim and mcp reach us only as transitive deps of pydantic-ai, so they
+# were unpinned and every rebuild took whatever was newest. fastmcp-slim 4.0.0
+# dropped the mcp<2.0 cap, pip then took mcp 2.x, and 2.x renamed
+# ToolsCapability.listChanged — which pydantic-ai 2.16.0 still reads. That took
+# the MIO agent down on 2026-09-01: every query died. Pinned to the versions
+# this agent is verified running.
+fastmcp-slim==3.4.4
+mcp==1.28.1
 pydantic-ai-harness==0.10.0
 python-dotenv>=1.0.0
 markdown-it-py