prism-mcp-server 20.2.7 → 20.2.9

package/dist/utils/qualityGate.js

@@ -1,12 +1,4 @@
-/**
- * Quality Gate — deterministic check for obvious inference failures.
- *
- * NARROW by design: only high-precision signals that rarely false-positive.
- * Does NOT judge correctness — that's the grounding verifier's job.
- * Does NOT use refusal regex (too many false positives on legitimate output).
- *
- * Returns: { pass: boolean, reason?: string }
- */
+import { parseRouteOutput } from "./routeContract.js";
 /**
  * Signal 5 — Tool-call bleed: pipe-delimited format leaking into non-tool turns.
  * Matches <|tool_call|> and <|tool_call_end|> only — NOT angle-bracket <tool_call> variants
@@ -37,11 +29,22 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
     if (finishReason === "length") {
         return { pass: false, reason: "hard_truncation" };
     }
-    // Signal 5: Tool-call bleed — fine-tuned 4b emits <|tool_call|> format in non-tool turns.
-    // Pipe-delimited format only; angle-bracket variants are handled by normalizeToolCallFormat.
-    // False-positive guard: requires the literal pipe tokens, not the words "tool call".
+    // Signal 5: Tool-call bleed. The pipe envelope is invalid in chat/code,
+    // but it is the canonical trained output in route mode. Route mode parses
+    // the whole envelope and fails only when the contract is malformed.
     if (TOOL_CALL_BLEED_RE.test(stripped)) {
-        return { pass: false, reason: "tool_call_bleed" };
+        if (mode === "route") {
+            const parsedRoute = parseRouteOutput(stripped);
+            if (parsedRoute.kind === "tool_call") {
+                // Continue through the remaining generic loop checks.
+            }
+            else {
+                return { pass: false, reason: "route_tool_call_malformed" };
+            }
+        }
+        else {
+            return { pass: false, reason: "tool_call_bleed" };
+        }
     }
     // Signal 4: Exact-loop detection (two passes).
     //

package/dist/utils/routeContract.js

@@ -0,0 +1,319 @@
+/**
+ * Generic route-output contract for prism_infer.
+ *
+ * This module deliberately contains no intent taxonomy or benchmark-derived
+ * routing heuristics. It only parses the public Prism tool-call envelope and
+ * enforces the caller-advertised registry before a host can act on a route.
+ */
+export const DEFAULT_PRISM_ROUTE_TOOLS = new Set([
+    "session_load_context",
+    "session_save_ledger",
+    "session_save_handoff",
+    "session_compact_ledger",
+    "session_search_memory",
+    "knowledge_search",
+    "brave_web_search",
+]);
+const PIPE_START = "<|tool_call|>";
+const PIPE_END = "<|tool_call_end|>";
+const ANGLE_START = "<tool_call>";
+const ANGLE_END = "</tool_call>";
+const TOOL_NAME_RE = /^[A-Za-z][A-Za-z0-9_.:-]{0,127}$/;
+const MAX_ROUTE_OUTPUT_CHARS = 32_000;
+const MAX_ROUTE_REASON_CHARS = 256;
+const MAX_ARGUMENT_DEPTH = 32;
+const MAX_ARGUMENT_NODES = 2_048;
+const TOOL_CALL_KEYS = new Set(["name", "arguments", "args"]);
+export function isRouteToolName(value) {
+    return typeof value === "string" && TOOL_NAME_RE.test(value);
+}
+function isBoundedJsonValue(root) {
+    const stack = [{ value: root, depth: 0 }];
+    let nodes = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        nodes += 1;
+        if (nodes > MAX_ARGUMENT_NODES || current.depth > MAX_ARGUMENT_DEPTH) {
+            return false;
+        }
+        if (current.value === null)
+            continue;
+        if (typeof current.value === "number") {
+            if (!Number.isFinite(current.value))
+                return false;
+            continue;
+        }
+        if (typeof current.value === "string" ||
+            typeof current.value === "boolean") {
+            continue;
+        }
+        if (typeof current.value !== "object")
+            return false;
+        const values = Array.isArray(current.value)
+            ? current.value
+            : Object.values(current.value);
+        for (const value of values) {
+            stack.push({ value, depth: current.depth + 1 });
+        }
+    }
+    return true;
+}
+function primitiveLeaves(value) {
+    const leaves = [];
+    const stack = [value];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current !== null && typeof current === "object") {
+            stack.push(...(Array.isArray(current)
+                ? current
+                : Object.values(current)));
+        }
+        else {
+            leaves.push(current);
+        }
+    }
+    return leaves;
+}
+function promptContainsPrimitive(prompt, value) {
+    const rendered = String(value).toLowerCase()
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[^A-Za-z0-9_.-])${rendered}($|[^A-Za-z0-9_.-])`)
+        .test(prompt.toLowerCase());
+}
+function promptContainsString(prompt, value) {
+    const normalizedValue = value.trim().toLowerCase();
+    if (!normalizedValue)
+        return false;
+    if (/^[A-Za-z0-9_.:-]+$/.test(normalizedValue)) {
+        const escaped = normalizedValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`(^|[^A-Za-z0-9_.:-])${escaped}($|[^A-Za-z0-9_.:-])`)
+            .test(prompt.toLowerCase());
+    }
+    return prompt.toLowerCase().includes(normalizedValue);
+}
+function sameJsonValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((entry, index) => sameJsonValue(entry, right[index]));
+    }
+    if (left === null ||
+        right === null ||
+        typeof left !== "object" ||
+        typeof right !== "object") {
+        return false;
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).sort();
+    const rightKeys = Object.keys(rightRecord).sort();
+    return leftKeys.length === rightKeys.length &&
+        leftKeys.every((key, index) => key === rightKeys[index] &&
+            sameJsonValue(leftRecord[key], rightRecord[key]));
+}
+function hasDerivedArguments(correctedArgs, originalArgs, originalPrompt) {
+    const originalLeaves = primitiveLeaves(originalArgs);
+    return primitiveLeaves(correctedArgs).every((leaf) => {
+        if (originalLeaves.some((candidate) => Object.is(candidate, leaf))) {
+            return true;
+        }
+        if (typeof leaf === "string") {
+            return promptContainsString(originalPrompt, leaf);
+        }
+        if (typeof leaf === "number" || typeof leaf === "boolean") {
+            return promptContainsPrimitive(originalPrompt, leaf);
+        }
+        return false;
+    });
+}
+function parseToolJson(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return { kind: "malformed" };
+        }
+        const record = value;
+        if (!isRouteToolName(record.name)) {
+            return { kind: "malformed" };
+        }
+        if (Object.keys(record).some((key) => !TOOL_CALL_KEYS.has(key))) {
+            return { kind: "malformed" };
+        }
+        const hasArguments = Object.prototype.hasOwnProperty.call(record, "arguments");
+        const hasArgs = Object.prototype.hasOwnProperty.call(record, "args");
+        if (hasArguments && hasArgs)
+            return { kind: "malformed" };
+        const rawArgs = hasArguments
+            ? record.arguments
+            : hasArgs
+                ? record.args
+                : {};
+        if (!rawArgs || typeof rawArgs !== "object" || Array.isArray(rawArgs)) {
+            return { kind: "malformed" };
+        }
+        if (!isBoundedJsonValue(rawArgs))
+            return { kind: "malformed" };
+        return {
+            kind: "tool_call",
+            name: record.name,
+            args: rawArgs,
+        };
+    }
+    catch {
+        return { kind: "malformed" };
+    }
+}
+function parseEnvelope(output, startToken, endToken) {
+    const start = output.indexOf(startToken);
+    const end = output.indexOf(endToken, start + startToken.length);
+    if (start < 0 ||
+        end < 0 ||
+        output.indexOf(startToken, start + startToken.length) >= 0 ||
+        output.indexOf(endToken, end + endToken.length) >= 0) {
+        return { kind: "malformed" };
+    }
+    const before = output.slice(0, start).trim();
+    const after = output.slice(end + endToken.length).trim();
+    if (before || after)
+        return { kind: "malformed" };
+    return parseToolJson(output.slice(start + startToken.length, end).trim());
+}
+export function parseRouteOutput(output) {
+    if (output.length > MAX_ROUTE_OUTPUT_CHARS)
+        return { kind: "malformed" };
+    const trimmed = output.trim();
+    const hasPipeMarker = trimmed.includes(PIPE_START) || trimmed.includes(PIPE_END);
+    if (hasPipeMarker)
+        return parseEnvelope(trimmed, PIPE_START, PIPE_END);
+    const hasAngleMarker = trimmed.includes(ANGLE_START) || trimmed.includes(ANGLE_END);
+    if (hasAngleMarker)
+        return parseEnvelope(trimmed, ANGLE_START, ANGLE_END);
+    // A route answer that starts like raw tool JSON is an attempted contract
+    // response. Treat invalid JSON/shape as malformed rather than returning it
+    // as ordinary prose that a host might accidentally interpret.
+    if (trimmed.startsWith("{"))
+        return parseToolJson(trimmed);
+    return { kind: "plain_text" };
+}
+export function applyLocalRouteContract(draft, allowedTools = DEFAULT_PRISM_ROUTE_TOOLS) {
+    const parsed = parseRouteOutput(draft);
+    if (parsed.kind === "plain_text") {
+        return { output: draft, action: "plain_text", source: "local" };
+    }
+    if (parsed.kind === "malformed") {
+        return {
+            output: "NO_TOOL",
+            action: "suppressed",
+            source: "local",
+            reason: "malformed_tool_call",
+        };
+    }
+    if (parsed.name === "NO_TOOL") {
+        return { output: "NO_TOOL", action: "plain_text", source: "local" };
+    }
+    if (!allowedTools.has(parsed.name)) {
+        return {
+            output: "NO_TOOL",
+            action: "suppressed",
+            source: "local",
+            original_tool: parsed.name,
+            reason: "unadvertised_tool",
+        };
+    }
+    return {
+        output: draft,
+        action: "preserved",
+        source: "local",
+        original_tool: parsed.name,
+        final_tool: parsed.name,
+    };
+}
+/**
+ * Validate a private portal correction before trusting it.
+ *
+ * The portal is an authenticated service, but the public client still treats
+ * its response as untrusted network input. The declared action must agree with
+ * the output shape and with the original draft.
+ */
+export function validatePortalRouteGuardOutcome(value, originalDraft, allowedTools, originalPrompt = "") {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (typeof record.output !== "string" ||
+        record.output.length === 0 ||
+        record.output.length > MAX_ROUTE_OUTPUT_CHARS ||
+        record.source !== "portal" ||
+        !["plain_text", "preserved", "remapped", "suppressed"].includes(typeof record.action === "string" ? record.action : "")) {
+        return null;
+    }
+    if (record.original_tool !== undefined &&
+        !isRouteToolName(record.original_tool)) {
+        return null;
+    }
+    if (record.final_tool !== undefined &&
+        !isRouteToolName(record.final_tool)) {
+        return null;
+    }
+    if (record.reason !== undefined &&
+        (typeof record.reason !== "string" ||
+            record.reason.length > MAX_ROUTE_REASON_CHARS)) {
+        return null;
+    }
+    const action = record.action;
+    const original = parseRouteOutput(originalDraft);
+    const corrected = parseRouteOutput(record.output);
+    if (action === "plain_text") {
+        if (original.kind !== "plain_text" || corrected.kind !== "plain_text") {
+            return null;
+        }
+    }
+    else if (action === "suppressed") {
+        if (original.kind !== "tool_call" ||
+            record.output.trim() !== "NO_TOOL" ||
+            (record.original_tool !== undefined &&
+                record.original_tool !== original.name) ||
+            record.final_tool !== undefined) {
+            return null;
+        }
+    }
+    else {
+        if (original.kind !== "tool_call" ||
+            corrected.kind !== "tool_call" ||
+            !allowedTools.has(corrected.name) ||
+            record.original_tool !== original.name ||
+            record.final_tool !== corrected.name) {
+            return null;
+        }
+        if (action === "preserved" && corrected.name !== original.name) {
+            return null;
+        }
+        if (action === "remapped" && corrected.name === original.name) {
+            return null;
+        }
+        if (action === "preserved" &&
+            !sameJsonValue(corrected.args, original.args)) {
+            return null;
+        }
+        if (action === "remapped" &&
+            !hasDerivedArguments(corrected.args, original.args, originalPrompt)) {
+            return null;
+        }
+    }
+    return {
+        output: record.output,
+        action,
+        source: "portal",
+        ...(record.original_tool !== undefined
+            ? { original_tool: record.original_tool }
+            : {}),
+        ...(record.final_tool !== undefined
+            ? { final_tool: record.final_tool }
+            : {}),
+        ...(record.reason !== undefined
+            ? { reason: record.reason }
+            : {}),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.2.7",
+  "version": "20.2.9",
   "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 or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
@@ -22,7 +22,7 @@
     "prebuild": "npm run clean",
     "build": "tsc && npm run chmod-bins",
     "chmod-bins": "node -e \"['dist/cli.js','dist/server.js','dist/utils/universalImporter.js'].forEach(f => { try { require('fs').chmodSync(f, 0o755); } catch (e) { console.warn('chmod skipped', f, e.message); } })\"",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "node scripts/check-publish-clean.mjs && npm run build",
     "lint:dashboard": "node scripts/lint-dashboard-es5.cjs",
     "start": "node dist/server.js",
     "test": "vitest run",