prism-mcp-server 17.0.0 → 17.0.1

package/dist/utils/braveApi.js

@@ -29,8 +29,20 @@
  * The Brave Answers endpoint uses a separate BRAVE_ANSWERS_API_KEY via Bearer token.
  */
 import { BRAVE_API_KEY, BRAVE_ANSWERS_API_KEY } from "../config.js";
+import { SYNALUX_SEARCH_AVAILABLE, synaluxWebSearch, synaluxWebSearchRaw, synaluxLocalSearch, synaluxLocalSearchRaw, synaluxBraveAnswers, } from "./synaluxSearch.js";
+import { debugLog } from "./logger.js";
 // Brave Answers API call (AI Grounding/OpenAI-compatible)
 export async function performBraveAnswers(query, model = "brave") {
+    // Route through Synalux portal when available
+    if (SYNALUX_SEARCH_AVAILABLE) {
+        try {
+            return await synaluxBraveAnswers(query, model);
+        }
+        catch (err) {
+            debugLog(`[braveApi] Synalux answers failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
+            // Fall through to direct Brave API
+        }
+    }
     if (!BRAVE_ANSWERS_API_KEY) {
         throw new Error("BRAVE_ANSWERS_API_KEY is not configured");
     }
@@ -62,6 +74,16 @@ export async function performBraveAnswers(query, model = "brave") {
 }
 // Raw web search API call
 export async function performWebSearchRaw(query, count = 10, offset = 0) {
+    // Route through Synalux portal when available (offset=0 only — portal doesn't support offset)
+    if (SYNALUX_SEARCH_AVAILABLE && offset === 0) {
+        try {
+            return await synaluxWebSearchRaw(query, count);
+        }
+        catch (err) {
+            debugLog(`[braveApi] Synalux search failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
+            // Fall through to direct Brave API
+        }
+    }
     const url = new URL("https://api.search.brave.com/res/v1/web/search");
     url.searchParams.set("q", query);
     url.searchParams.set("count", Math.min(count, 20).toString()); // API limit
@@ -81,6 +103,16 @@ export async function performWebSearchRaw(query, count = 10, offset = 0) {
 }
 // Web search API call
 export async function performWebSearch(query, count = 10, offset = 0) {
+    // Route through Synalux portal when available (offset=0 only — portal doesn't support offset)
+    if (SYNALUX_SEARCH_AVAILABLE && offset === 0) {
+        try {
+            return await synaluxWebSearch(query, count);
+        }
+        catch (err) {
+            debugLog(`[braveApi] Synalux search failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
+            // Fall through to direct Brave API
+        }
+    }
     const textData = await performWebSearchRaw(query, count, offset);
     const data = JSON.parse(textData);
     // Extract just web results
@@ -136,6 +168,16 @@ function chunkArray(arr, size) {
 }
 // Raw local search API call with poi/details payload
 export async function performLocalSearchRaw(query, count = 5) {
+    // Route through Synalux portal when available
+    if (SYNALUX_SEARCH_AVAILABLE) {
+        try {
+            return await synaluxLocalSearchRaw(query, count);
+        }
+        catch (err) {
+            debugLog(`[braveApi] Synalux local search raw failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
+            // Fall through to direct Brave API
+        }
+    }
     // Initial search to get location IDs
     const webUrl = new URL("https://api.search.brave.com/res/v1/web/search");
     webUrl.searchParams.set("q", query);
@@ -190,6 +232,16 @@ export async function performLocalSearchRaw(query, count = 5) {
 }
 // Local search API call with poi details
 export async function performLocalSearch(query, count = 5) {
+    // Route through Synalux portal when available
+    if (SYNALUX_SEARCH_AVAILABLE) {
+        try {
+            return await synaluxLocalSearch(query, count);
+        }
+        catch (err) {
+            debugLog(`[braveApi] Synalux local search failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
+            // Fall through to direct Brave API
+        }
+    }
     const rawData = await performLocalSearchRaw(query, count);
     const parsed = JSON.parse(rawData);
     if (parsed.source === "web_fallback") {

package/dist/utils/synaluxSearch.js

@@ -0,0 +1,195 @@
+/**
+ * Synalux Portal Search & Scrape Client
+ * ─────────────────────────────────────────────────────────────
+ * Routes web search and scrape calls through the Synalux portal
+ * so API keys (Brave, Firecrawl, etc.) live server-side. The
+ * portal endpoints:
+ *
+ *   POST /api/v1/prism/search  — { query, limit? }
+ *        returns { status, results: [{title, url, description}], source }
+ *
+ *   POST /api/v1/prism/scrape  — { url, formats?, onlyMainContent?, waitFor? }
+ *        returns { status, content }
+ *
+ * Auth uses the shared JWT exchange from synaluxJwt.ts (same
+ * refresh-token dance as SynaluxStorage, but without requiring
+ * the full storage class). Falls back gracefully: callers check
+ * SYNALUX_SEARCH_AVAILABLE before calling.
+ */
+import { debugLog } from "./logger.js";
+import { getSynaluxJwt, invalidateSynaluxJwt } from "./synaluxJwt.js";
+import { PRISM_SYNALUX_BASE_URL, SYNALUX_CONFIGURED, } from "../config.js";
+// ─── Public availability flag ────────────────────────────────
+/** True when Synalux portal credentials are configured. */
+export const SYNALUX_SEARCH_AVAILABLE = SYNALUX_CONFIGURED;
+// ─── Internal helpers ────────────────────────────────────────
+/**
+ * POST to a portal endpoint with JWT auth. Retries once on 401
+ * (JWT may have just expired). Throws on network or HTTP errors.
+ */
+async function portalPost(path, body, timeoutMs = 15_000) {
+    const baseUrl = PRISM_SYNALUX_BASE_URL.replace(/\/+$/, "");
+    const url = `${baseUrl}${path}`;
+    const send = async (jwt) => {
+        return fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${jwt}`,
+                "X-Prism-Client": "prism-mcp-search",
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    };
+    let jwt = await getSynaluxJwt();
+    if (!jwt) {
+        throw new Error("[synaluxSearch] JWT exchange failed — no token available");
+    }
+    let res = await send(jwt);
+    // Retry once on 401 (stale JWT)
+    if (res.status === 401) {
+        debugLog("[synaluxSearch] 401 on first attempt, re-exchanging JWT");
+        invalidateSynaluxJwt();
+        jwt = await getSynaluxJwt();
+        if (!jwt) {
+            throw new Error("[synaluxSearch] JWT re-exchange failed after 401");
+        }
+        res = await send(jwt);
+    }
+    if (!res.ok) {
+        const text = await res.text().catch(() => "(no body)");
+        throw new Error(`[synaluxSearch] ${path} HTTP ${res.status}: ${text}`);
+    }
+    return (await res.json());
+}
+// ─── Public API ──────────────────────────────────────────────
+/**
+ * Web search via Synalux portal. Returns formatted text matching
+ * the shape of performWebSearch() in braveApi.ts.
+ */
+export async function synaluxWebSearch(query, count = 10) {
+    debugLog(`[synaluxSearch] web search: q="${query}", limit=${count}`);
+    const data = await portalPost("/api/v1/prism/search", {
+        query,
+        limit: Math.min(count, 20),
+    });
+    if (data.status === "error") {
+        throw new Error(`[synaluxSearch] portal error: ${data.error || "unknown"}`);
+    }
+    const results = (data.results || []).map((r) => ({
+        title: r.title || "",
+        description: r.description || "",
+        url: r.url || "",
+    }));
+    debugLog(`[synaluxSearch] got ${results.length} results (source=${data.source || "portal"})`);
+    return results
+        .map((r) => `Title: ${r.title}\nDescription: ${r.description}\nURL: ${r.url}`)
+        .join("\n\n");
+}
+/**
+ * Web search via Synalux portal — returns raw JSON string.
+ * Used by code-mode handlers that pass raw data to the QuickJS sandbox.
+ */
+export async function synaluxWebSearchRaw(query, count = 10) {
+    debugLog(`[synaluxSearch] web search raw: q="${query}", limit=${count}`);
+    const data = await portalPost("/api/v1/prism/search", {
+        query,
+        limit: Math.min(count, 20),
+    });
+    if (data.status === "error") {
+        throw new Error(`[synaluxSearch] portal error: ${data.error || "unknown"}`);
+    }
+    // Re-shape into the Brave-compatible format that code-mode handlers expect
+    const braveCompatible = {
+        web: {
+            results: (data.results || []).map((r) => ({
+                title: r.title || "",
+                description: r.description || "",
+                url: r.url || "",
+            })),
+        },
+    };
+    debugLog(`[synaluxSearch] raw: ${braveCompatible.web.results.length} results`);
+    return JSON.stringify(braveCompatible);
+}
+/**
+ * Local/POI search via Synalux portal.
+ * Returns formatted text matching performLocalSearch() shape.
+ */
+export async function synaluxLocalSearch(query, count = 5) {
+    debugLog(`[synaluxSearch] local search: q="${query}", count=${count}`);
+    const data = await portalPost("/api/v1/prism/local-search", {
+        query,
+        count: Math.min(count, 20),
+    });
+    if (data.status === "error") {
+        throw new Error(`[synaluxSearch] portal error: ${data.error || "unknown"}`);
+    }
+    const results = data.results || [];
+    debugLog(`[synaluxSearch] local: got ${results.length} results`);
+    return results
+        .map((r) => `Name: ${r.name || "N/A"}\nAddress: ${r.address || "N/A"}\nPhone: ${r.phone || "N/A"}\nRating: ${r.rating || "N/A"}\nHours: ${r.hours || "N/A"}\nDescription: ${r.description || "No description available"}`)
+        .join("\n---\n");
+}
+/**
+ * Local/POI search raw — returns JSON string for code-mode sandbox.
+ */
+export async function synaluxLocalSearchRaw(query, count = 5) {
+    debugLog(`[synaluxSearch] local search raw: q="${query}", count=${count}`);
+    const data = await portalPost("/api/v1/prism/local-search", {
+        query,
+        count: Math.min(count, 20),
+    });
+    if (data.status === "error") {
+        throw new Error(`[synaluxSearch] portal error: ${data.error || "unknown"}`);
+    }
+    const results = data.results || [];
+    debugLog(`[synaluxSearch] local raw: ${results.length} results`);
+    // Build envelope compatible with code-mode sandbox expectations
+    const envelope = {
+        source: "local",
+        query,
+        count,
+        poisData: { results },
+        descriptionsData: {
+            descriptions: Object.fromEntries(results.map((r, i) => [String(i), r.description || ""])),
+        },
+    };
+    return JSON.stringify(envelope);
+}
+/**
+ * AI-grounded answers via Synalux portal.
+ */
+export async function synaluxBraveAnswers(query, model) {
+    debugLog(`[synaluxSearch] answers: q="${query}", model=${model || "default"}`);
+    const body = { query };
+    if (model)
+        body.model = model;
+    const data = await portalPost("/api/v1/prism/answers", body);
+    if (data.status === "error") {
+        throw new Error(`[synaluxSearch] portal error: ${data.error || "unknown"}`);
+    }
+    if (!data.answer) {
+        throw new Error("[synaluxSearch] answers endpoint returned empty answer");
+    }
+    return data.answer;
+}
+/**
+ * Scrape a URL via Synalux portal. Returns the extracted content string.
+ */
+export async function synaluxScrape(url, options) {
+    debugLog(`[synaluxSearch] scrape: url="${url}"`);
+    const body = { url };
+    if (options?.formats)
+        body.formats = options.formats;
+    if (options?.onlyMainContent !== undefined)
+        body.onlyMainContent = options.onlyMainContent;
+    if (options?.waitFor !== undefined)
+        body.waitFor = options.waitFor;
+    const data = await portalPost("/api/v1/prism/scrape", body);
+    if (data.status === "error") {
+        throw new Error(`[synaluxSearch] scrape error: ${data.error || "unknown"}`);
+    }
+    return data.content || "";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "17.0.0",
+  "version": "17.0.1",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 54 Agent Skills, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder:7b / 14b open-weights LLM fleet.",
   "module": "index.ts",