@kinqs/brainrouter-mcp-server 0.3.4

package/dist/integrations/generic-mcp.js

@@ -0,0 +1,118 @@
+import { randomUUID } from "node:crypto";
+import { redactSensitiveMemoryText } from "../memory/redaction.js";
+import { resetWorkingMemory } from "../memory/working/offload.js";
+const registeredHooks = new Map();
+const SECRET_KEY_PATTERN = /(api[_-]?key|authorization|bearer|password|secret|token)/i;
+const MAX_STRING_LENGTH = 4_000;
+const MAX_ARRAY_ITEMS = 25;
+const MAX_OBJECT_KEYS = 50;
+const SESSION_END_EVENTS = new Set(["Stop", "SubagentStop", "session_end"]);
+function truncate(value) {
+    return value.length > MAX_STRING_LENGTH
+        ? `${value.slice(0, MAX_STRING_LENGTH)}...[truncated]`
+        : value;
+}
+export function sanitizeHookPayload(value, depth = 0) {
+    if (depth > 6)
+        return "[TRUNCATED_DEPTH]";
+    if (value === null || typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (typeof value === "string")
+        return redactSensitiveMemoryText(truncate(value));
+    if (typeof value === "undefined")
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.slice(0, MAX_ARRAY_ITEMS).map((item) => sanitizeHookPayload(item, depth + 1));
+    }
+    if (typeof value === "object") {
+        const output = {};
+        for (const [key, item] of Object.entries(value).slice(0, MAX_OBJECT_KEYS)) {
+            output[key] = SECRET_KEY_PATTERN.test(key)
+                ? "[REDACTED]"
+                : sanitizeHookPayload(item, depth + 1);
+        }
+        return output;
+    }
+    return String(value);
+}
+export function registerHostHook(params) {
+    const now = new Date().toISOString();
+    const id = `${params.userId}:${params.source}:${params.sessionKey ?? "global"}`;
+    const existing = registeredHooks.get(id);
+    const hook = {
+        id,
+        userId: params.userId,
+        source: params.source,
+        events: params.events ?? existing?.events ?? [],
+        sessionKey: params.sessionKey ?? existing?.sessionKey,
+        workspacePath: params.workspacePath ?? existing?.workspacePath,
+        registeredAt: existing?.registeredAt ?? now,
+        lastSeenAt: existing?.lastSeenAt ?? null,
+        lastEvent: existing?.lastEvent ?? null,
+        metadata: params.metadata ?? existing?.metadata ?? {},
+    };
+    registeredHooks.set(id, hook);
+    return hook;
+}
+export function listHostHooks(userId) {
+    return [...registeredHooks.values()]
+        .filter((hook) => hook.userId === userId)
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+function touchHook(event) {
+    const hook = registerHostHook({
+        userId: event.userId,
+        source: event.source,
+        events: [event.event],
+        sessionKey: event.sessionKey,
+        workspacePath: event.workspacePath,
+    });
+    hook.lastSeenAt = new Date().toISOString();
+    hook.lastEvent = event.event;
+    if (!hook.events.includes(event.event)) {
+        hook.events = [...hook.events, event.event];
+    }
+    registeredHooks.set(hook.id, hook);
+    return hook;
+}
+function buildCaptureContent(event) {
+    return JSON.stringify({
+        source: event.source,
+        event: event.event,
+        toolName: event.toolName,
+        args: sanitizeHookPayload(event.args),
+        result: sanitizeHookPayload(event.result),
+        prompt: sanitizeHookPayload(event.prompt),
+        content: sanitizeHookPayload(event.content),
+        metadata: sanitizeHookPayload(event.metadata ?? {}),
+    });
+}
+export async function processGenericMcpHook(engine, event) {
+    const hook = touchHook(event);
+    const capture = engine.capturePassiveL0({
+        userId: event.userId,
+        sessionKey: event.sessionKey,
+        sessionId: event.sessionId,
+        role: "tool",
+        content: buildCaptureContent(event),
+        timestamp: event.timestamp ?? Date.now(),
+        skillTag: `host:${event.source}`,
+    });
+    const workspacePath = event.workspacePath ?? hook.workspacePath;
+    const flushedWorkingMemory = SESSION_END_EVENTS.has(event.event) && Boolean(workspacePath);
+    if (flushedWorkingMemory && workspacePath) {
+        resetWorkingMemory(workspacePath, event.userId, event.sessionKey);
+    }
+    return {
+        hookId: hook.id,
+        l0RecordedCount: 1,
+        l0RecordId: capture.id,
+        flushedWorkingMemory,
+    };
+}
+export function buildHookResult(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+export function fallbackSessionKey(source) {
+    return `${source}-${randomUUID()}`;
+}

package/dist/loader.d.ts

@@ -0,0 +1,29 @@
+import type { Fragment, SkillSection, SkillScope } from './types.js';
+/**
+ * Load the entire file verbatim (minus frontmatter, which is prepended cleanly).
+ */
+export declare function loadFull(filePath: string, scope?: SkillScope): Fragment;
+/**
+ * Load only the frontmatter description field.
+ */
+export declare function loadDescription(filePath: string, scope?: SkillScope): Fragment;
+/**
+ * Load a named ## section from a markdown file.
+ */
+export declare function loadSection(filePath: string, sectionKey: Exclude<SkillSection, 'description' | 'full' | 'phases' | 'checklist'>, scope?: SkillScope): Fragment;
+/**
+ * Load all ### Phase N sub-blocks.
+ */
+export declare function loadPhases(filePath: string, scope?: SkillScope): Fragment;
+/**
+ * Load all checklist items from the file.
+ */
+export declare function loadChecklist(filePath: string, scope?: SkillScope): Fragment;
+/**
+ * Master dispatcher: load the correct fragment based on SkillSection.
+ */
+export declare function loadSkillSection(filePath: string, section: SkillSection, scope?: SkillScope): Fragment;
+/**
+ * Load a named ## heading from any markdown doc file (used for get_template_doc).
+ */
+export declare function loadDocSection(filePath: string, sectionHeading?: string): Fragment;

package/dist/loader.js

@@ -0,0 +1,200 @@
+// ─────────────────────────────────────────────
+// BrainRouter MCP Server — Markdown Loader
+// Reads and extracts sections from any markdown file on demand.
+// ─────────────────────────────────────────────
+import { readFileSync } from 'fs';
+import matter from 'gray-matter';
+/** Estimate token count: ~4 chars per token */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Heading aliases: maps SkillSection keys → possible ## heading strings.
+ * We match case-insensitively. First match wins.
+ */
+const SECTION_HEADINGS = {
+    overview: ['overview'],
+    when_to_use: ['when to use', 'when to invoke', 'triggers'],
+    workflow: ['workflow', 'core process', 'the workflow', 'steps', 'process', 'checklist', 'methodology', 'routine', 'guidelines', 'patterns', 'template', 'structure', 'lifecycle'],
+    usage: ['usage', 'example usage', 'examples'],
+    detailed_instructions: ['detailed instructions', 'instructions', 'detailed guide'],
+    red_flags: ['red flags', 'warning signs'],
+    rationalizations: ['common rationalizations', 'rationalizations'],
+};
+/**
+ * Split a markdown body (after frontmatter) into { heading, content } blocks.
+ * Only splits on ## level headings.
+ */
+function splitSections(body) {
+    const lines = body.split('\n');
+    const sections = [];
+    let currentHeading = '__preamble__';
+    let currentLines = [];
+    for (const line of lines) {
+        const h2Match = line.match(/^##\s+(.+)/);
+        if (h2Match) {
+            sections.push({ heading: currentHeading, content: currentLines.join('\n').trim() });
+            currentHeading = h2Match[1].trim();
+            currentLines = [];
+        }
+        else {
+            currentLines.push(line);
+        }
+    }
+    sections.push({ heading: currentHeading, content: currentLines.join('\n').trim() });
+    return sections;
+}
+/**
+ * Extract all ### Phase N sub-blocks from a body string.
+ */
+function extractPhases(body) {
+    const lines = body.split('\n');
+    const phaseLines = [];
+    let inPhase = false;
+    for (const line of lines) {
+        if (/^###\s+phase/i.test(line)) {
+            inPhase = true;
+        }
+        else if (/^##\s/.test(line)) {
+            inPhase = false;
+        }
+        if (inPhase)
+            phaseLines.push(line);
+    }
+    return phaseLines.join('\n').trim();
+}
+/**
+ * Extract all checklist items (- [ ] or - [x]) from a body string.
+ */
+function extractChecklist(body) {
+    return body
+        .split('\n')
+        .filter((l) => /^- \[[ x]\]/.test(l))
+        .join('\n')
+        .trim();
+}
+// ─── Public API ─────────────────────────────
+/**
+ * Load the entire file verbatim (minus frontmatter, which is prepended cleanly).
+ */
+export function loadFull(filePath, scope) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { content } = matter(raw);
+    return {
+        content: content.trim(),
+        source: filePath,
+        scope,
+        tokenEstimate: estimateTokens(content),
+    };
+}
+/**
+ * Load only the frontmatter description field.
+ */
+export function loadDescription(filePath, scope) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { data } = matter(raw);
+    const content = data.description ?? '';
+    return {
+        content,
+        source: filePath,
+        scope,
+        tokenEstimate: estimateTokens(content),
+    };
+}
+/**
+ * Load a named ## section from a markdown file.
+ */
+export function loadSection(filePath, sectionKey, scope) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { content } = matter(raw);
+    const sections = splitSections(content);
+    const aliases = SECTION_HEADINGS[sectionKey];
+    let match = sections.find((s) => aliases.some((alias) => s.heading.toLowerCase().includes(alias)));
+    // FALLBACK for Overview: If ## Overview is missing, use the preamble (text before first ##)
+    if (!match && sectionKey === 'overview') {
+        const preamble = sections.find(s => s.heading === '__preamble__');
+        if (preamble && preamble.content.length > 20) {
+            match = { heading: 'Overview', content: preamble.content };
+        }
+    }
+    const extracted = match
+        ? `## ${match.heading}\n\n${match.content}`
+        : `<!-- Section "${sectionKey}" not found in ${filePath} -->`;
+    return {
+        content: extracted.trim(),
+        source: filePath,
+        scope,
+        tokenEstimate: estimateTokens(extracted),
+    };
+}
+/**
+ * Load all ### Phase N sub-blocks.
+ */
+export function loadPhases(filePath, scope) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { content } = matter(raw);
+    const phases = extractPhases(content);
+    const result = phases || `<!-- No phase blocks found in ${filePath} -->`;
+    return {
+        content: result,
+        source: filePath,
+        scope,
+        tokenEstimate: estimateTokens(result),
+    };
+}
+/**
+ * Load all checklist items from the file.
+ */
+export function loadChecklist(filePath, scope) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { content } = matter(raw);
+    const checklist = extractChecklist(content);
+    const result = checklist || `<!-- No checklist items found in ${filePath} -->`;
+    return {
+        content: result,
+        source: filePath,
+        scope,
+        tokenEstimate: estimateTokens(result),
+    };
+}
+/**
+ * Master dispatcher: load the correct fragment based on SkillSection.
+ */
+export function loadSkillSection(filePath, section, scope) {
+    switch (section) {
+        case 'description':
+            return loadDescription(filePath, scope);
+        case 'full':
+            return loadFull(filePath, scope);
+        case 'phases':
+            return loadPhases(filePath, scope);
+        case 'checklist':
+            return loadChecklist(filePath, scope);
+        default:
+            return loadSection(filePath, section, scope);
+    }
+}
+/**
+ * Load a named ## heading from any markdown doc file (used for get_template_doc).
+ */
+export function loadDocSection(filePath, sectionHeading) {
+    const raw = readFileSync(filePath, 'utf-8');
+    const { content } = matter(raw);
+    if (!sectionHeading) {
+        return {
+            content: content.trim(),
+            source: filePath,
+            tokenEstimate: estimateTokens(content),
+        };
+    }
+    const sections = splitSections(content);
+    const match = sections.find((s) => s.heading.toLowerCase().includes(sectionHeading.toLowerCase()));
+    const extracted = match
+        ? `## ${match.heading}\n\n${match.content}`
+        : `<!-- Section "${sectionHeading}" not found in ${filePath} -->`;
+    return {
+        content: extracted.trim(),
+        source: filePath,
+        tokenEstimate: estimateTokens(extracted),
+    };
+}

package/dist/memory/capture.d.ts

@@ -0,0 +1,35 @@
+import type { IMemoryStore } from "@kinqs/brainrouter-types";
+import type { CaptureResult, LLMRunner, CognitiveExtractionStatus } from "@kinqs/brainrouter-types";
+import type { EmbeddingService } from "./store/embedding.js";
+export declare class MemoryCapturePipeline {
+    private store;
+    private llmRunner;
+    private embeddingService;
+    private extractEveryNTurns;
+    constructor(store: IMemoryStore, llmRunner: LLMRunner, embeddingService: EmbeddingService, extractEveryNTurns?: number);
+    captureTurn(params: {
+        userId: string;
+        sessionKey: string;
+        sessionId?: string;
+        messages: {
+            role: string;
+            content: string;
+            timestamp: number;
+        }[];
+        activeSkill?: string;
+        skillHints?: string;
+    }): Promise<CaptureResult>;
+    processBacklog(params: {
+        userId: string;
+        sessionKey: string;
+        sessionId?: string;
+        activeSkill?: string;
+        skillHints?: string;
+    }): Promise<{
+        triggered: boolean;
+        extractedCount: number;
+        status: CognitiveExtractionStatus;
+        errorMessage?: string;
+    }>;
+    private extractPendingSensory;
+}

package/dist/memory/capture.js

@@ -0,0 +1,230 @@
+import { extractCognitiveMemories } from "./pipeline/cognitive-extractor.js";
+import { deduplicateMemories } from "./pipeline/cognitive-dedup.js";
+import { detectContradictions } from "./pipeline/cognitive-contradiction.js";
+import { buildGraphFromCognitive } from "./pipeline/graph-builder.js";
+import { distillFocusScenes } from "./pipeline/contextual-focus-builder.js";
+import { distillCoreIdentity } from "./pipeline/identity-distiller.js";
+import { detectFocusShift } from "./pipeline/focus-direction-shift.js";
+import { shouldRunFocusDistill, shouldRunIdentityDistill } from "./scheduler.js";
+import { NeuralSparkEngine } from "./pipeline/neural-spark.js";
+import { redactSensitiveMemoryText } from "./redaction.js";
+import crypto from "node:crypto";
+export class MemoryCapturePipeline {
+    store;
+    llmRunner;
+    embeddingService;
+    extractEveryNTurns;
+    constructor(store, llmRunner, embeddingService, extractEveryNTurns = 3) {
+        this.store = store;
+        this.llmRunner = llmRunner;
+        this.embeddingService = embeddingService;
+        this.extractEveryNTurns = extractEveryNTurns;
+    }
+    async captureTurn(params) {
+        const { userId, sessionKey, sessionId = "", messages, activeSkill, skillHints } = params;
+        const nowStr = new Date().toISOString();
+        const sensoryRecords = [];
+        // 1. Write Sensory Records atomically
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            const record = {
+                id: `sensory_${sessionKey}_${msg.timestamp}_${i}_${crypto.randomBytes(3).toString("hex")}`,
+                userId,
+                sessionKey,
+                sessionId,
+                role: msg.role,
+                messageText: redactSensitiveMemoryText(msg.content),
+                recordedAt: nowStr,
+                timestamp: msg.timestamp,
+                skillTag: activeSkill || "",
+            };
+            this.store.upsertSensory(record);
+            sensoryRecords.push(record);
+        }
+        // 2. Decide if we should trigger Cognitive extraction
+        const unextractedCount = this.store.getUnextractedSensoryCount(userId, sessionKey);
+        let cognitiveExtractionTriggered = false;
+        let cognitiveExtractedCount = 0;
+        let cognitiveExtractionStatus = "skipped";
+        let cognitiveExtractionError;
+        if (unextractedCount >= this.extractEveryNTurns) {
+            const result = await this.extractPendingSensory({ userId, sessionKey, sessionId, activeSkill, skillHints });
+            cognitiveExtractionTriggered = result.triggered;
+            cognitiveExtractedCount = result.extractedCount;
+            cognitiveExtractionStatus = result.status;
+            cognitiveExtractionError = result.errorMessage;
+        }
+        return {
+            sensoryRecordedCount: sensoryRecords.length,
+            cognitiveExtractionTriggered,
+            cognitiveExtractedCount,
+            cognitiveExtractionStatus,
+            cognitiveExtractionError,
+        };
+    }
+    async processBacklog(params) {
+        return this.extractPendingSensory(params);
+    }
+    async extractPendingSensory(params) {
+        const { userId, sessionKey, sessionId = "", activeSkill, skillHints } = params;
+        const recentSensory = this.store.getRecentSensoryMessages(userId, sessionKey, 20);
+        if (recentSensory.length === 0) {
+            return { triggered: false, extractedCount: 0, status: "skipped" };
+        }
+        const extractionResult = await extractCognitiveMemories({
+            messages: recentSensory,
+            userId,
+            sessionKey,
+            sessionId,
+            llmRunner: this.llmRunner,
+            activeSkill,
+            existingSceneNames: this.store.getTopContextualFocus(userId, 20).map(s => s.sceneName),
+            skillHints: skillHints ?? (activeSkill ? this.store.getSkillHints(activeSkill) ?? undefined : undefined)
+        });
+        if (!extractionResult.success) {
+            this.store.recordExtractionFailure(userId, extractionResult.errorMessage ?? "Cognitive extraction failed");
+            return {
+                triggered: true,
+                extractedCount: 0,
+                status: "failed",
+                errorMessage: extractionResult.errorMessage ?? "Cognitive extraction failed",
+            };
+        }
+        this.store.markSensoryExtracted(userId, sessionKey, recentSensory.map((record) => record.id));
+        this.store.resetExtractionFailures(userId);
+        if (extractionResult.records.length === 0) {
+            // LLM returned an empty list — legitimate "nothing notable" outcome
+            // (e.g. a greeting or trivial exchange). Status is "ok" so the CLI
+            // doesn't surface a misleading "extractor broke" warning.
+            return { triggered: true, extractedCount: 0, status: "ok" };
+        }
+        // Run active deduplication BEFORE storing
+        const { uniqueRecords, droppedCount } = await deduplicateMemories({
+            records: extractionResult.records,
+            store: this.store,
+            userId
+        });
+        if (droppedCount > 0) {
+            console.log(`[BrainRouter] Dropped ${droppedCount} duplicate cognitive memories.`);
+        }
+        // Write to store
+        for (const record of uniqueRecords) {
+            this.store.upsertCognitive(record);
+            // Non-blocking background embedding (Slice A)
+            if (this.embeddingService.isReady()) {
+                this.embeddingService.embed(record.content)
+                    .then((vec) => {
+                    this.store.upsertCognitiveVec(record.id, vec);
+                })
+                    .catch((err) => {
+                    console.error(`[BrainRouter] Background embedding failed for ${record.id}:`, err.message);
+                });
+            }
+            // Non-blocking contradiction check (Slice C)
+            detectContradictions({
+                newRecord: record,
+                store: this.store,
+                llmRunner: this.llmRunner
+            }).catch((err) => {
+                console.error(`[BrainRouter] Background contradiction check failed for ${record.id}:`, err.message);
+            });
+            // Non-blocking graph extraction (GraphRAG Slice)
+            buildGraphFromCognitive({
+                record,
+                store: this.store,
+                llmRunner: this.llmRunner
+            }).catch((err) => {
+                console.error(`[BrainRouter] Background graph extraction failed for ${record.id}:`, err.message);
+            });
+        }
+        // --- Seeding Dendritic Spine Connections ---
+        for (let i = 0; i < uniqueRecords.length; i++) {
+            const recA = uniqueRecords[i];
+            // 1. Connect with other records extracted in this same batch/turn
+            for (let j = i + 1; j < uniqueRecords.length; j++) {
+                const recB = uniqueRecords[j];
+                this.store.upsertConnection(userId, recA.id, recB.id, 0.5);
+                this.store.upsertConnection(userId, recB.id, recA.id, 0.5);
+            }
+            // 2. Connect with existing active records sharing the same focus scene name
+            if (recA.sceneName) {
+                const matchingRecords = this.store.getCognitivesByFocus(userId, recA.sceneName, 10);
+                for (const match of matchingRecords) {
+                    if (match.record_id !== recA.id) {
+                        this.store.upsertConnection(userId, recA.id, match.record_id, 0.5);
+                        this.store.upsertConnection(userId, match.record_id, recA.id, 0.5);
+                    }
+                }
+            }
+        }
+        const cognitiveExtractedCount = uniqueRecords.length;
+        if (cognitiveExtractedCount === 0) {
+            // All extracted records were duplicates of existing memories — the
+            // LLM ran fine, dedup just dropped everything. Still "ok".
+            return { triggered: true, extractedCount: 0, status: "ok" };
+        }
+        // Update scheduler counters
+        this.store.incrementSchedulerCognitiveCount(userId, cognitiveExtractedCount);
+        // Check if Focus distillation should fire
+        const topScenes = this.store.getTopContextualFocus(userId, 1);
+        if (topScenes.length > 0) {
+            detectFocusShift({
+                activeScene: topScenes[0],
+                newCognitiveRecords: uniqueRecords,
+                llmRunner: this.llmRunner,
+            }).then(shiftResult => {
+                if (shiftResult.shift && shiftResult.confidence >= 0.75) {
+                    console.error(`[BrainRouter] Focus shift detected (confidence=${shiftResult.confidence.toFixed(2)}): ${shiftResult.reason}. Triggering focus distillation.`);
+                    this.store.resetSchedulerFocusCount(userId);
+                    try {
+                        const sparkEngine = new NeuralSparkEngine(this.store);
+                        sparkEngine.decayAndPrune(userId);
+                    }
+                    catch (err) {
+                        console.error("[BrainRouter] LTD decay and prune failed:", err.message);
+                    }
+                    distillFocusScenes({ userId, store: this.store, llmRunner: this.llmRunner })
+                        .catch(err => console.error("[BrainRouter] Background focus distillation failed:", err.message));
+                }
+                else {
+                    const countState = this.store.getSchedulerState(userId);
+                    if (shouldRunFocusDistill(countState)) {
+                        this.store.resetSchedulerFocusCount(userId);
+                        try {
+                            const sparkEngine = new NeuralSparkEngine(this.store);
+                            sparkEngine.decayAndPrune(userId);
+                        }
+                        catch (err) {
+                            console.error("[BrainRouter] LTD decay and prune failed:", err.message);
+                        }
+                        distillFocusScenes({ userId, store: this.store, llmRunner: this.llmRunner })
+                            .catch(err => console.error("[BrainRouter] Background focus distillation failed:", err.message));
+                    }
+                }
+            }).catch(err => console.error("[BrainRouter] Background focus shift detection failed:", err.message));
+        }
+        else {
+            const countState = this.store.getSchedulerState(userId);
+            if (shouldRunFocusDistill(countState)) {
+                this.store.resetSchedulerFocusCount(userId);
+                try {
+                    const sparkEngine = new NeuralSparkEngine(this.store);
+                    sparkEngine.decayAndPrune(userId);
+                }
+                catch (err) {
+                    console.error("[BrainRouter] LTD decay and prune failed:", err.message);
+                }
+                distillFocusScenes({ userId, store: this.store, llmRunner: this.llmRunner })
+                    .catch(err => console.error("[BrainRouter] Background focus distillation failed:", err.message));
+            }
+        }
+        // Check if Core Identity distillation should fire
+        const identityState = this.store.getSchedulerState(userId);
+        if (shouldRunIdentityDistill(identityState)) {
+            this.store.resetSchedulerIdentityCount(userId);
+            distillCoreIdentity({ userId, store: this.store, llmRunner: this.llmRunner })
+                .catch(err => console.error("[BrainRouter] Background core identity distillation failed:", err.message));
+        }
+        return { triggered: true, extractedCount: cognitiveExtractedCount, status: "ok" };
+    }
+}

package/dist/memory/config.d.ts

@@ -0,0 +1,2 @@
+export type BrainRouterLlmMode = "server" | "agent";
+export declare function getBrainRouterLlmMode(): BrainRouterLlmMode;

package/dist/memory/config.js

@@ -0,0 +1,3 @@
+export function getBrainRouterLlmMode() {
+    return process.env.BRAINROUTER_LLM_MODE === "agent" ? "agent" : "server";
+}