@brainpilot/web 0.0.9 → 0.0.11

package/src/utils/api.ts

@@ -66,13 +66,44 @@ function authHeaders(json = true): Record<string, string> {
   return json ? { "Content-Type": "application/json" } : {};
 }
 
+/**
+ * #206: build a readable message from a Zod issue list. The backend returns
+ * `details: parsed.error.issues` — each issue has a `path` (field) and a
+ * `message`. We render `field: message` per issue so a validation 400 tells the
+ * user *which* field is wrong (empty name, invalid url, …) instead of degrading
+ * to a generic "Request failed (400)".
+ */
+function formatIssues(details: unknown): string | null {
+  if (!Array.isArray(details) || details.length === 0) return null;
+  const parts: string[] = [];
+  for (const issue of details) {
+    if (!issue || typeof issue !== "object") continue;
+    const { path, message } = issue as { path?: unknown; message?: unknown };
+    if (typeof message !== "string" || message.length === 0) continue;
+    const field = Array.isArray(path) ? path.filter((p) => p !== "" && p != null).join(".") : "";
+    parts.push(field ? `${field}: ${message}` : message);
+  }
+  return parts.length > 0 ? parts.join("; ") : null;
+}
+
 async function parseError(res: Response): Promise<string> {
   const contentType = res.headers.get("content-type") || "";
   if (contentType.includes("application/json")) {
-    const body = (await res.json().catch(() => null)) as { detail?: unknown } | null;
-    if (typeof body?.detail === "string") {
+    // #206: the backend uses two shapes — `{ detail }` (single string) and the
+    // Zod validation shape `{ error, details }`. parseError previously read only
+    // `detail`, so every `{ error, details }` 400/409 fell through to the generic
+    // text fallback. Read all three: detail → error(+formatted details) → error.
+    const body = (await res.json().catch(() => null)) as
+      | { detail?: unknown; error?: unknown; details?: unknown }
+      | null;
+    if (typeof body?.detail === "string" && body.detail.length > 0) {
       return body.detail;
     }
+    const issues = formatIssues(body?.details);
+    if (typeof body?.error === "string" && body.error.length > 0) {
+      return issues ? `${body.error} (${issues})` : body.error;
+    }
+    if (issues) return issues;
   }
   const text = await res.text().catch(() => "");
   return text || `Request failed (${res.status})`;
@@ -519,7 +550,14 @@ export const api = {
         `${API_BASE}/sessions/${sessionId}/history${qs}`,
         { headers: authHeaders() },
       );
-      if (!res.ok) return { events: [], total: 0, truncated: false };
+      // A 404 means the session has no transcript on disk (genuinely empty) —
+      // return an empty history. Any OTHER non-OK status is a real failure
+      // (routing / storage / auth); surface it instead of silently rendering an
+      // empty transcript, which historically masked broken rehydrates (#223).
+      if (res.status === 404) return { events: [], total: 0, truncated: false };
+      if (!res.ok) {
+        throw new Error(`history fetch failed: ${res.status} ${res.statusText}`);
+      }
       const raw = (await res.json().catch(() => null)) as
         | { events?: unknown[]; total?: number; truncated?: boolean }
         | null;
@@ -735,4 +773,151 @@ export const api = {
       return normalizeProviderProfile(raw as Parameters<typeof normalizeProviderProfile>[0]);
     },
   },
+
+  // Knowledge Base — local pipeline build orchestration.
+  // Mirrors the backend /api/kb/* routes. The SSE event stream is consumed
+  // directly via `new EventSource()` in the panel component (so it can stay
+  // attached for the lifetime of the dialog), so we don't expose a helper
+  // here for it.
+  kb: {
+    async build(opts: {
+      ocrApiKey?: string;
+      metaApiKey?: string;
+      metaBaseUrl?: string;
+      metaModel?: string;
+      kbRoot?: string;
+      ocrConcurrency?: number;
+      ocrLimit?: number;
+      skip?: Array<"ocr" | "extract" | "chunk" | "vectorize">;
+      only?: Array<"ocr" | "extract" | "chunk" | "vectorize">;
+      hfMirror?: string;
+    }): Promise<{ ok: boolean; startedAt?: number; error?: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/build`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(opts),
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        return { ok: false, error: body.error || `kb build failed (${res.status})` };
+      }
+      return handleJson(res);
+    },
+
+    async status(): Promise<{
+      active: boolean;
+      startedAt: number | null;
+      finishedAt: number | null;
+      exitCode: number | null | undefined;
+      error?: string;
+      recentEvents: Array<{
+        ts: string;
+        stage: string;
+        event: string;
+        msg: string;
+        [k: string]: unknown;
+      }>;
+      environment: {
+        python: string;
+        pythonIsVenv: boolean;
+        venvExists: boolean;
+        expectedVenvPath: string;
+        scriptsPresent: boolean;
+        kbRoot: string;
+      };
+    }> {
+      return handleJson(await apiFetch(`${API_BASE}/kb/status`));
+    },
+
+    async cancel(): Promise<{ ok: boolean; message?: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/cancel`, { method: "POST" });
+      return res.json().catch(() => ({ ok: false }));
+    },
+
+    // Bootstrap the Python venv (KnowledgeBase/.venv) before the first
+    // build can run. Streams progress on the same SSE channel as `build`,
+    // so the panel only needs one EventSource subscription.
+    async setupEnv(opts: {
+      python?: string;
+      reinstall?: boolean;
+      kbRoot?: string;
+    } = {}): Promise<{ ok: boolean; startedAt?: number; error?: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/setup-env`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(opts),
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        return { ok: false, error: body.error || `setup-env failed (${res.status})` };
+      }
+      return handleJson(res);
+    },
+
+    // Download bge-m3 + bge-reranker-v2-m3 model weights (~2.5 GB) via
+    // `scripts/setup_models.py`. Independent slot from setupEnv — the two
+    // can run concurrently, and setupFull() chains them.
+    async setupModels(opts: {
+      hfMirror?: string;
+      kbRoot?: string;
+    } = {}): Promise<{ ok: boolean; startedAt?: number; error?: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/setup-models`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(opts),
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        return { ok: false, error: body.error || `setup-models failed (${res.status})` };
+      }
+      return handleJson(res);
+    },
+
+    // One-click orchestration: create venv, then download models when venv
+    // exits 0. Preferred entry point from the KB panel — one button, two
+    // progress rows in the UI.
+    async setupFull(opts: {
+      python?: string;
+      reinstall?: boolean;
+      hfMirror?: string;
+      kbRoot?: string;
+    } = {}): Promise<{ ok: boolean; startedAt?: number; error?: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/setup-full`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(opts),
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        return { ok: false, error: body.error || `setup-full failed (${res.status})` };
+      }
+      return handleJson(res);
+    },
+
+    // Persisted KB API config (SiliconFlow OCR key today). Backend never
+    // returns the plaintext — only a masked preview + boolean — so the
+    // browser can indicate "already saved" without ever holding the secret.
+    async getApiConfig(): Promise<{ hasOcrApiKey: boolean; ocrApiKeyPreview: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/api-config`);
+      if (!res.ok) return { hasOcrApiKey: false, ocrApiKeyPreview: "" };
+      return handleJson(res);
+    },
+
+    async saveApiConfig(patch: { ocrApiKey?: string }): Promise<{ ok: boolean; error?: string }> {
+      const res = await apiFetch(`${API_BASE}/kb/api-config`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(patch),
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        return { ok: false, error: body.error || `save failed (${res.status})` };
+      }
+      return handleJson(res);
+    },
+
+    eventsUrl(): string {
+      return `${API_BASE}/kb/events`;
+    },
+  },
 };

package/src/utils/format.ts

@@ -5,3 +5,12 @@ export function formatBytes(bytes: number) {
   const value = bytes / 1024 ** index;
   return `${value >= 10 ? value.toFixed(0) : value.toFixed(1)} ${units[index]}`;
 }
+
+/** Compact elapsed formatter: "3.2s" under a minute, "1m 05s" above. */
+export function formatElapsed(ms: number): string {
+  const totalSeconds = Math.max(0, ms) / 1000;
+  if (totalSeconds < 60) return `${totalSeconds.toFixed(1)}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = Math.floor(totalSeconds % 60);
+  return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}