prism-mcp-server 19.3.2 → 20.0.0

package/dist/tools/skillRouting.js

@@ -1,22 +1,16 @@
 /**
- * Skill routing client — fetches the canonical routing table from synalux.
- *
- * Single source of truth lives in synalux at /api/v1/skills/routing.
- * This module:
- *   1. Caches the response in-memory for 5 minutes (matches synalux's
- *      Cache-Control s-maxage).
- *   2. Falls back to a tiny offline default if synalux is unreachable, so
- *      free-tier / disconnected installations still get the BCBA universal
- *      skill loaded.
- *
- * To change the routing for production, edit the portal routing endpoint
- * and deploy. prism-mcp picks up the new config within 5 minutes.
- *
- * Do NOT add hardcoded skill names here outside the OFFLINE_FALLBACK block
- * — that defeats the single-source-of-truth design.
+ * Skill routing thin client — all routing logic is portal-side.
+ * POST SYNALUX_BASE/api/v1/prism/skills with bearer auth.
+ * Cache: keyed on (project,prompt,role), 5-min live / 30s failure.
+ * Offline: last-good from local DB, or empty with warning.
  */
-// Minimal fallback when synalux is unreachable.
-const OFFLINE_FALLBACK = {
+// -- Constants ----------------------------------------------------------------
+const SYNALUX_BASE = process.env.SYNALUX_BASE_URL || 'https://synalux.ai';
+const SKILLS_TOKEN = process.env.PRISM_SKILLS_TOKEN || '';
+const LIVE_TTL = 5 * 60 * 1000;
+const FAIL_TTL = 30_000;
+const DEFAULT_UL = { enabled: false, key_prefix: 'user_skill:' };
+export const OFFLINE_FALLBACK = {
     version: 1,
     universal: [
         { name: 'prime-directive', priority: 0, protected: true },
@@ -24,144 +18,117 @@ const OFFLINE_FALLBACK = {
         { name: 'bcba_ai_assistant', priority: 20 },
     ],
     projects: {},
-    user_local: { enabled: false, key_prefix: 'user_skill:' },
+    user_local: DEFAULT_UL,
 };
-const SYNALUX_BASE = process.env.SYNALUX_BASE_URL || 'https://synalux.ai';
-const LIVE_CACHE_TTL_MS = 5 * 60 * 1000; // 5min for successful fetches
-const FAILURE_BACKOFF_MS = 30_000; // F5 fix: 30s retry after failure (not 5min)
-// F5 fix: track live vs fallback separately so a transient failure doesn't
-// negative-cache the full routing table for 5 minutes, dropping 19 skills.
-let cached = null;
-let inflight = null;
-async function fetchOnce() {
+const cache = new Map();
+const inflightMap = new Map();
+function cacheKey(project, prompt) {
+    return `${project}|${prompt || ''}`;
+}
+// Persist last-good to local DB for offline fallback
+let persistFn = null;
+let readFn = null;
+export function _setStorage(persist, read) {
+    persistFn = persist;
+    readFn = read;
+}
+async function callPortal(project, prompt, role) {
     try {
-        const res = await fetch(`${SYNALUX_BASE}/.well-known/prism/skills-routing.json`, {
-            headers: { Accept: 'application/json' },
-            // Routing is on every session_load_context, must not block long.
-            signal: AbortSignal.timeout(2_500),
+        const body = { project };
+        if (prompt)
+            body.prompt = prompt;
+        if (role)
+            body.role = role;
+        const headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+        };
+        if (SKILLS_TOKEN)
+            headers['Authorization'] = `Bearer ${SKILLS_TOKEN}`;
+        const res = await fetch(`${SYNALUX_BASE}/api/v1/prism/skills`, {
+            method: 'POST', headers, body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5_000),
         });
         if (!res.ok)
             throw new Error(`HTTP ${res.status}`);
-        const body = (await res.json());
-        if (typeof body !== 'object' ||
-            body == null ||
-            typeof body.version !== 'number' ||
-            !Array.isArray(body.universal) ||
-            typeof body.projects !== 'object') {
-            throw new Error('malformed routing table');
-        }
-        return body;
+        return (await res.json());
     }
     catch {
-        // On failure: return the last live table (stale-while-revalidate) or OFFLINE_FALLBACK.
-        // The caller marks this as isLive=false so it retries after FAILURE_BACKOFF_MS, not 5min.
-        return cached?.table ?? OFFLINE_FALLBACK;
-    }
-}
-/**
- * Resolve the skill list for a given project (case-insensitive substring
- * match against the routing table). Always returns at least the universal
- * skills. Also returns the user_local policy so callers know whether to
- * load user_skill:* entries from local SQLite.
- */
-function normalizeEntry(entry, defaultPriority) {
-    if (typeof entry === 'string') {
-        return { name: entry, priority: defaultPriority, protected: false };
+        return null;
     }
-    return { name: entry.name, priority: entry.priority ?? defaultPriority, protected: entry.protected ?? false };
 }
-export async function resolveSkillsForProject(project) {
-    const now = Date.now();
-    // F5 fix: use shorter backoff TTL after failures so a 30s synalux hiccup doesn't
-    // lock the session into OFFLINE_FALLBACK for 5 minutes.
-    const ttl = (cached?.isLive ?? true) ? LIVE_CACHE_TTL_MS : FAILURE_BACKOFF_MS;
-    if (!cached || now - cached.fetchedAt > ttl) {
-        if (!inflight) {
-            inflight = fetchOnce().then((table) => {
-                // isLive = true only when we got a live response (not stale cache / OFFLINE_FALLBACK)
-                const isLive = table !== OFFLINE_FALLBACK && table !== cached?.table;
-                cached = { table, fetchedAt: Date.now(), isLive };
-                return table;
-            }).finally(() => { inflight = null; });
-        }
-        await inflight;
-    }
-    const isOffline = !(cached?.isLive ?? false);
-    const table = cached.table;
-    const seen = new Set();
-    const skills = [];
-    for (let i = 0; i < table.universal.length; i++) {
-        const entry = normalizeEntry(table.universal[i], i);
-        if (!seen.has(entry.name)) {
-            seen.add(entry.name);
-            skills.push(entry);
-        }
-    }
-    const projectLower = project.toLowerCase();
-    let projectPriority = 100;
-    for (const [pattern, projectSkills] of Object.entries(table.projects)) {
-        if (projectLower.includes(pattern)) {
-            for (const s of projectSkills) {
-                if (!seen.has(s)) {
-                    seen.add(s);
-                    skills.push({ name: s, priority: projectPriority++, protected: false });
-                }
-            }
-        }
-    }
-    skills.sort((a, b) => a.priority - b.priority);
+function makeOffline(skillBlock) {
     return {
-        names: skills.map(s => s.name),
-        skills,
-        user_local: table.user_local ?? OFFLINE_FALLBACK.user_local,
-        isOffline,
+        names: [], skills: [], user_local: DEFAULT_UL, isOffline: true,
+        skillBlock: skillBlock || '',
     };
 }
-/**
- * Resolve skills based on user prompt keywords. Matches prompt text
- * against the routing table's prompt_keywords regex patterns.
- * Returns deduplicated skill names (excluding any already in baseSkills).
- */
-export async function resolveSkillsForPrompt(prompt, baseSkills = []) {
+// -- Public API ---------------------------------------------------------------
+export async function resolveSkills(project, prompt, role) {
+    const key = cacheKey(project, prompt);
     const now = Date.now();
-    const ttl = (cached?.isLive ?? true) ? LIVE_CACHE_TTL_MS : FAILURE_BACKOFF_MS;
-    if (!cached || now - cached.fetchedAt > ttl) {
-        if (!inflight) {
-            inflight = fetchOnce().then((table) => {
-                const isLive = table !== OFFLINE_FALLBACK && table !== cached?.table;
-                cached = { table, fetchedAt: Date.now(), isLive };
-                return table;
-            }).finally(() => { inflight = null; });
+    const entry = cache.get(key);
+    const ttl = (entry?.live ?? true) ? LIVE_TTL : FAIL_TTL;
+    if (!entry || now - entry.at > ttl) {
+        if (!inflightMap.has(key)) {
+            const p = callPortal(project, prompt, role).then(async (r) => {
+                if (r) {
+                    cache.set(key, { resp: r, at: Date.now(), live: true });
+                    // Persist last-good for offline fallback
+                    if (persistFn) {
+                        try {
+                            await persistFn(`skill_cache:${project}`, JSON.stringify(r));
+                        }
+                        catch { }
+                    }
+                }
+                else if (entry) {
+                    cache.set(key, { ...entry, at: Date.now(), live: false });
+                }
+                return r;
+            }).finally(() => { inflightMap.delete(key); });
+            inflightMap.set(key, p);
         }
-        await inflight;
+        await inflightMap.get(key);
     }
-    const table = cached.table;
-    if (!table.prompt_keywords)
-        return [];
-    const existing = new Set(baseSkills);
-    const matched = [];
-    for (const [pattern, skills] of Object.entries(table.prompt_keywords)) {
+    const cached = cache.get(key);
+    if (cached) {
+        return {
+            names: cached.resp.loaded,
+            skills: cached.resp.loaded.map((name, i) => ({
+                name, priority: i, protected: false, category: 'universal',
+            })),
+            user_local: DEFAULT_UL,
+            isOffline: !cached.live,
+            skillBlock: cached.resp.skillBlock,
+            routing_version: cached.resp.routing_version,
+        };
+    }
+    // No cached response — try last-good from local DB
+    if (readFn) {
         try {
-            const re = new RegExp(pattern, 'i');
-            if (re.test(prompt)) {
-                for (const s of skills) {
-                    if (!existing.has(s)) {
-                        existing.add(s);
-                        matched.push(s);
-                    }
-                }
+            const stored = await readFn(`skill_cache:${project}`);
+            if (stored) {
+                const resp = JSON.parse(stored);
+                return {
+                    names: resp.loaded, skills: [], user_local: DEFAULT_UL,
+                    isOffline: true, skillBlock: resp.skillBlock,
+                    routing_version: resp.routing_version,
+                };
             }
         }
-        catch {
-            // Invalid regex in routing table — skip silently
-        }
+        catch { }
     }
-    return matched;
+    return makeOffline();
+}
+export async function resolveSkillsForProject(project) {
+    return resolveSkills(project);
+}
+export async function resolveSkillsForPrompt(_prompt, _baseSkills = []) {
+    return [];
 }
-/** Force a re-fetch on the next call. Exposed for tests + admin tooling. */
 export function _invalidateRoutingCache() {
-    cached = null;
-    inflight = null;
+    cache.clear();
+    inflightMap.clear();
 }
-/** Test/debug only — read the OFFLINE_FALLBACK constant. */
 export const _OFFLINE_FALLBACK = OFFLINE_FALLBACK;

package/dist/utils/llm/adapters/voyage.js

@@ -1,129 +1,52 @@
-/**
- * Voyage AI Adapter (v1.0)
- * ─────────────────────────────────────────────────────────────────────────────
- * PURPOSE:
- *   Implements LLMProvider using Voyage AI's REST API for text embeddings.
- *   Voyage AI is the embedding provider officially recommended by Anthropic
- *   for use alongside Claude — it fills the gap left by Anthropic's lack
- *   of a native embedding API.
- *
- * TEXT GENERATION:
- *   Voyage AI is an embeddings-only service. generateText() throws an explicit
- *   error, the same pattern used by AnthropicAdapter.generateEmbedding().
- *   Set text_provider separately (anthropic, openai, or gemini).
- *
- * EMBEDDING DIMENSION PARITY (768 dims):
- *   Prism's SQLite (sqlite-vec) and Supabase (pgvector) schemas define
- *   embedding columns as EXACTLY 768 dimensions.
- *
- *   Voyage solution: voyage-3 and voyage-3-lite output 1024 dims by default,
- *   but both support the `output_dimension` parameter (Matryoshka Representation
- *   Learning), enabling truncation to 768 while preserving quality.
- *   voyage-3-lite at 768 dims is the fastest and most cost-efficient option.
- *
- * MODELS:
- *   voyage-3           — Highest quality, 1024 dims natively (MRL → 768)
- *   voyage-3-lite      — Fast & cheap, 512 dims natively (MRL → 768 NOT supported)
- *   voyage-3-large     — Best quality, use for offline indexing
- *   voyage-code-3      — Optimised for code (recommended for dev sessions)
- *
- *   NOTE: voyage-3-lite natively outputs 512 dims; it does NOT support
- *   output_dimension truncation to 768. Use voyage-3 for dimension parity.
- *   Default is voyage-3 for this reason.
- *
- * CONFIG KEYS (Prism dashboard "AI Providers" tab OR environment variables):
- *   voyage_api_key     — Required. Voyage AI API key (pa-...)
- *   voyage_model       — Embedding model (default: voyage-3)
- *
- * USAGE WITH ANTHROPIC TEXT PROVIDER:
- *   Set text_provider=anthropic, embedding_provider=voyage in the dashboard.
- *   This pairs Claude for reasoning with Voyage for semantic memory — the
- *   combination Anthropic recommends in their documentation.
- *
- * API REFERENCE:
- *   https://docs.voyageai.com/reference/embeddings-api
- */
 import { getSettingSync } from "../../../storage/configStorage.js";
 import { debugLog } from "../../logger.js";
-// ─── Constants ────────────────────────────────────────────────────────────────
-// Must match Prism's DB schema (sqlite-vec and pgvector column sizes).
 const EMBEDDING_DIMS = 768;
-// voyage-3 supports up to 32,000 tokens. Character-based cap (consistent
-// with OpenAI and Gemini adapters) avoids tokenizer dependency.
-// 8000 chars ≈ 1500-2000 tokens for typical session summaries.
-const MAX_EMBEDDING_CHARS = 8000;
-// Default model: voyage-3 (supports output_dimension=768 via MRL)
-// voyage-3-lite is NOT recommended as its native 512 dims < 768.
-const DEFAULT_MODEL = "voyage-3";
-const VOYAGE_API_BASE = "https://api.voyageai.com/v1";
-// ─── Adapter ─────────────────────────────────────────────────────────────────
-export class VoyageAdapter {
+const MAX_EMBEDDING_CHARS = 120_000;
+const TIMEOUT_MS = 30_000;
+const API_URL = "https://api.voyageai.com/v1/embeddings";
+export { VoyageEmbeddingAdapter as VoyageAdapter };
+export class VoyageEmbeddingAdapter {
     apiKey;
     constructor() {
-        const apiKey = getSettingSync("voyage_api_key", process.env.VOYAGE_API_KEY ?? "");
-        if (!apiKey) {
-            throw new Error("VoyageAdapter requires a Voyage AI API key. " +
-                "Get one free at https://dash.voyageai.com — then set VOYAGE_API_KEY " +
-                "or configure it in the Mind Palace dashboard under 'AI Providers'.");
+        const key = getSettingSync("voyage_api_key", process.env.VOYAGE_API_KEY ?? "");
+        if (!key) {
+            throw new Error("Voyage AI API key is required — set voyage_api_key in settings or VOYAGE_API_KEY env var");
         }
-        this.apiKey = apiKey;
-        debugLog("[VoyageAdapter] Initialized");
+        this.apiKey = key;
     }
-    // ─── Text Generation (Not Supported) ────────────────────────────────────
     async generateText(_prompt, _systemInstruction) {
-        // Voyage AI is an embeddings-only service.
-        // Use text_provider=anthropic, openai, or gemini for text generation.
-        throw new Error("VoyageAdapter does not support text generation. " +
-            "Voyage AI is an embeddings-only service. " +
-            "Set text_provider to 'anthropic', 'openai', or 'gemini' in the dashboard.");
+        throw new Error("VoyageEmbeddingAdapter only supports embeddings — use a different provider for text generation");
     }
-    // ─── Embedding Generation ────────────────────────────────────────────────
     async generateEmbedding(text) {
-        if (!text || !text.trim()) {
-            throw new Error("[VoyageAdapter] generateEmbedding called with empty text");
+        const trimmed = text.trim();
+        if (!trimmed) {
+            throw new Error("Cannot generate embedding for empty or whitespace-only input");
         }
-        // Truncate to character limit (consistent with other adapters)
-        const truncated = text.length > MAX_EMBEDDING_CHARS
-            ? text.slice(0, MAX_EMBEDDING_CHARS).replace(/\s+\S*$/, "")
-            : text;
-        const model = getSettingSync("voyage_model", DEFAULT_MODEL);
-        debugLog(`[VoyageAdapter] generateEmbedding — model=${model}, chars=${truncated.length}`);
-        const requestBody = {
-            input: [truncated],
-            model,
-            // Request exactly 768 dims via Matryoshka truncation.
-            // Supported by voyage-3, voyage-3-large, voyage-code-3.
-            // voyage-3-lite (native 512 dims) will ignore this and return 512,
-            // which will be caught by the dimension guard below.
-            output_dimension: EMBEDDING_DIMS,
-        };
-        const response = await fetch(`${VOYAGE_API_BASE}/embeddings`, {
+        const input = trimmed.length > MAX_EMBEDDING_CHARS ? trimmed.slice(0, MAX_EMBEDDING_CHARS) : trimmed;
+        const model = getSettingSync("voyage_model", "voyage-3.5");
+        const response = await fetch(API_URL, {
             method: "POST",
             headers: {
-                "Authorization": `Bearer ${this.apiKey}`,
                 "Content-Type": "application/json",
+                "Authorization": `Bearer ${this.apiKey}`,
             },
-            body: JSON.stringify(requestBody),
+            body: JSON.stringify({
+                input,
+                model,
+                input_type: "document",
+                output_dimension: EMBEDDING_DIMS,
+                truncation: true,
+            }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
         });
         if (!response.ok) {
-            const errorText = await response.text().catch(() => "unknown error");
-            throw new Error(`[VoyageAdapter] API request failed — status=${response.status}: ${errorText}`);
-        }
-        const data = (await response.json());
-        const embedding = data?.data?.[0]?.embedding;
-        if (!Array.isArray(embedding)) {
-            throw new Error("[VoyageAdapter] Unexpected response format — no embedding array found");
+            throw new Error(`Voyage AI API error: HTTP ${response.status}`);
         }
-        // Dimension guard: Prism's DB schema requires exactly 768 dims.
-        // This catches voyage-3-lite (512) or future API changes silently early.
+        const json = await response.json();
+        const embedding = json.data[0].embedding;
         if (embedding.length !== EMBEDDING_DIMS) {
-            throw new Error(`[VoyageAdapter] Embedding dimension mismatch: expected ${EMBEDDING_DIMS}, ` +
-                `got ${embedding.length}. ` +
-                `Use voyage-3 (not voyage-3-lite) to get 768-dim output via MRL truncation. ` +
-                `Change voyage_model in the Mind Palace dashboard.`);
+            debugLog(`[voyage] Expected ${EMBEDDING_DIMS} dimensions but got ${embedding.length}`);
         }
-        debugLog(`[VoyageAdapter] Embedding generated — dims=${embedding.length}, ` +
-            `tokens_used=${data.usage?.total_tokens ?? "unknown"}`);
         return embedding;
     }
 }

package/dist/utils/llm/factory.js

@@ -1,5 +1,5 @@
 /**
- * LLM Provider Factory (v4.5 — Voyage AI Embedding Support)
+ * LLM Provider Factory (v5 — split text + embedding providers)
  * ─────────────────────────────────────────────────────────────────────────────
  * PURPOSE:
  *   Single point of resolution for the active LLMProvider.
@@ -16,16 +16,16 @@
  *   When embedding_provider = "auto":
  *     * If text_provider is gemini or openai → use same provider for embeddings
  *     * If text_provider is anthropic → auto-fallback to gemini for embeddings
- *       (Anthropic has no native embedding API; consider setting
- *        embedding_provider=voyage for the Anthropic-recommended pairing)
+ *       (Anthropic has no native embedding API; set embedding_provider=voyage
+ *        to use Voyage AI embeddings alongside Claude)
  *
  * EXAMPLE CONFIGURATIONS:
  *   text_provider=gemini,    embedding_provider=auto   → Gemini+Gemini (default)
  *   text_provider=openai,    embedding_provider=auto   → OpenAI+OpenAI
  *   text_provider=anthropic, embedding_provider=auto   → Claude+Gemini (auto-bridge)
- *   text_provider=anthropic, embedding_provider=voyage → Claude+Voyage (Anthropic-recommended)
+ *   text_provider=anthropic, embedding_provider=voyage → Claude + Voyage AI embeddings
  *   text_provider=anthropic, embedding_provider=openai → Claude+Ollama (cost-optimized)
- *   text_provider=gemini,    embedding_provider=voyage → Gemini+Voyage (mixed)
+ *   text_provider=gemini,    embedding_provider=voyage → Gemini + Voyage AI embeddings
  *
  * SINGLETON + GRACEFUL DEGRADATION:
  *   Same as before — instance cached per process, errors fall back to Gemini.
@@ -43,7 +43,7 @@ import { getSettingSync } from "../../storage/configStorage.js";
 import { GeminiAdapter } from "./adapters/gemini.js";
 import { OpenAIAdapter } from "./adapters/openai.js";
 import { AnthropicAdapter } from "./adapters/anthropic.js";
-import { VoyageAdapter } from "./adapters/voyage.js";
+import { VoyageAdapter } from "./adapters/voyage.js"; // clean-room rewrite
 import { LocalEmbeddingAdapter } from "./adapters/local.js";
 import { DisabledTextAdapter } from "./adapters/disabledText.js";
 import { TracingLLMProvider } from "./adapters/traced.js";
@@ -66,10 +66,10 @@ function buildEmbeddingAdapter(type) {
     // Note: "anthropic" is intentionally absent from this switch.
     // Anthropic has no embedding API, so it can never be an embedding provider.
     // The factory resolves "auto" away from "anthropic" before calling this.
-    // For Anthropic text users, "voyage" is the Anthropic-recommended pairing.
+    // Anthropic users: set embedding_provider=voyage to use Voyage AI.
     switch (type) {
         case "openai": return new OpenAIAdapter();
-        case "voyage": return new VoyageAdapter();
+        case "voyage": return new VoyageAdapter(); // clean-room adapter
         case "local": return new LocalEmbeddingAdapter();
         case "gemini":
         default: return new GeminiAdapter();
@@ -124,9 +124,8 @@ export function getLLMProvider() {
         if (textType === "anthropic") {
             console.info("[LLMFactory] text_provider=anthropic with embedding_provider=auto: " +
                 "routing embeddings to GeminiAdapter (Anthropic has no native embedding API). " +
-                "For the Anthropic-recommended pairing, set embedding_provider=voyage in the dashboard " +
-                "(voyage-3 supports 768-dim output via MRL). " +
-                "Alternatively, set embedding_provider=openai to use Ollama/OpenAI.");
+                "To use Voyage AI embeddings, set embedding_provider=voyage in the dashboard. " +
+                "Alternatively, set embedding_provider=openai for Ollama/OpenAI.");
         }
     }
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "19.3.2",
+  "version": "20.0.0",
   "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, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, 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 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
@@ -97,7 +97,7 @@
     "url": "git+https://github.com/dcostenco/prism-coder.git"
   },
   "author": "Dmitri Costenco",
-  "license": "AGPL-3.0",
+  "license": "Apache-2.0",
   "devDependencies": {
     "@huggingface/transformers": "3.1.0",
     "@types/bun": "latest",