fix: non-blocking manifest init, fetch timeout, stricter manifest parse

Author: clean6378-max-it

Makefile

@@ -1,4 +1,4 @@
-.PHONY: seed-baselines-local update-baselines check-benchmarks clean-benchmark-artifacts
+.PHONY: seed-baselines-local update-baselines gen-tool-types-manifest check-benchmarks clean-benchmark-artifacts
 
 # WARNING: captures timings on THIS machine. Production baselines must match ubuntu-latest CI.
 # Prefer downloading benchmark-results.json from a CI artifact, then:

static/js/app.js

@@ -49,11 +49,11 @@ function handleRoute() {
 
 // ==================== Bootstrap ====================
 
-document.addEventListener('DOMContentLoaded', async () => {
+document.addEventListener('DOMContentLoaded', () => {
     applyTheme(localStorage.getItem('theme') || 'dark');
     const yearEl = document.getElementById('footer-year');
     if (yearEl) yearEl.textContent = new Date().getFullYear();
-    await initToolTypesManifest();
+    void initToolTypesManifest();
     handleRoute();
     window.addEventListener('hashchange', handleRoute);
 

static/js/app.test.js

@@ -36,7 +36,6 @@ describe('router (app.js)', () => {
         Element.prototype.scrollIntoView = vi.fn();
         await import('./app.js');
         document.dispatchEvent(new Event('DOMContentLoaded'));
-        await Promise.resolve();
     });
 
     afterAll(() => {

static/js/render/tool_types_manifest.js

@@ -2,14 +2,17 @@ import { TOOL_USE_RENDERERS } from './registry.js';
 import { setManifestToolTypes } from './tool_types_state.js';
 
 const MANIFEST_URL = '/static/tool_types.json';
+const MANIFEST_FETCH_TIMEOUT_MS = 5000;
 
 /**
  * Load backend tool-type manifest and cross-check ``TOOL_USE_RENDERERS``.
  * Logs ``console.warn`` when the backend list and frontend registry diverge.
  */
 export async function initToolTypesManifest() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), MANIFEST_FETCH_TIMEOUT_MS);
     try {
-        const res = await fetch(MANIFEST_URL);
+        const res = await fetch(MANIFEST_URL, { signal: controller.signal });
         if (!res.ok) {
             console.warn(`[tool registry] Could not load ${MANIFEST_URL}: HTTP ${res.status}`);
             return;
@@ -34,6 +37,14 @@ export async function initToolTypesManifest() {
             }
         }
     } catch (err) {
+        if (err?.name === 'AbortError') {
+            console.warn(
+                `[tool registry] Could not load ${MANIFEST_URL}: timed out after ${MANIFEST_FETCH_TIMEOUT_MS}ms`,
+            );
+            return;
+        }
         console.warn('[tool registry] Could not load tool types manifest:', err);
+    } finally {
+        clearTimeout(timeoutId);
     }
 }

static/js/render/tool_types_manifest.test.js

@@ -46,4 +46,29 @@ describe('initToolTypesManifest', () => {
             expect.any(Error),
         );
     });
+
+    it('warns when fetch times out', async () => {
+        vi.useFakeTimers();
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+        vi.stubGlobal(
+            'fetch',
+            vi.fn((_url, init) =>
+                new Promise((_resolve, reject) => {
+                    init?.signal?.addEventListener('abort', () => {
+                        reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+                    });
+                }),
+            ),
+        );
+
+        const promise = initToolTypesManifest();
+        await vi.advanceTimersByTimeAsync(5000);
+        await promise;
+
+        expect(getManifestToolTypes()).toBeNull();
+        expect(warn).toHaveBeenCalledWith(
+            '[tool registry] Could not load /static/tool_types.json: timed out after 5000ms',
+        );
+        vi.useRealTimers();
+    });
 });

tests/test_tool_dispatch_sync.py

@@ -94,7 +94,13 @@ def _load_manifest_tool_types(path: Path) -> frozenset[str]:
     if not isinstance(raw, list):
         msg = f"Invalid tool_types in {path}: expected a JSON array"
         raise ValueError(msg)
-    return frozenset(str(t) for t in raw)
+    for i, item in enumerate(raw):
+        if not isinstance(item, str):
+            msg = (
+                f"Invalid tool_types[{i}] in {path}: expected string, got {type(item).__name__}"
+            )
+            raise ValueError(msg)
+    return frozenset(raw)
 
 
 def test_tool_types_manifest_matches_known_tool_types() -> None: