@j0hanz/memdb 1.1.5 → 1.2.2

package/dist/config.d.ts

@@ -1,4 +1,6 @@
+type LogLevel = 'error' | 'info' | 'warn';
 export declare const config: {
     dbPath: string;
-    logLevel: "info";
+    logLevel: LogLevel;
 };
+export {};

package/dist/config.js

@@ -2,12 +2,36 @@ import path from 'node:path';
 import process from 'node:process';
 const DEFAULT_DB_PATH = path.join(process.cwd(), '.memdb', 'memory.db');
 const DEFAULT_LOG_LEVEL = 'info';
+const hasNullByte = (value) => value.includes('\0');
+const parseLogLevel = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (hasNullByte(value)) {
+        throw new Error('Invalid MEMDB_LOG_LEVEL: null byte detected');
+    }
+    switch (value) {
+        case 'error':
+        case 'info':
+        case 'warn':
+            return value;
+        default:
+            throw new Error(`Invalid MEMDB_LOG_LEVEL: ${value} (expected: error|warn|info)`);
+    }
+};
 const resolveDbPath = (env) => {
-    if (env.MEMDB_PATH === ':memory:')
-        return ':memory:';
+    const envPath = env.MEMDB_PATH;
+    if (envPath !== undefined) {
+        if (hasNullByte(envPath)) {
+            throw new Error('Invalid MEMDB_PATH: null byte detected');
+        }
+        if (envPath === ':memory:')
+            return ':memory:';
+        if (envPath.length > 0)
+            return path.resolve(envPath);
+    }
     return path.resolve(DEFAULT_DB_PATH);
 };
 export const config = {
     dbPath: resolveDbPath(process.env),
-    logLevel: DEFAULT_LOG_LEVEL,
+    logLevel: parseLogLevel(process.env.MEMDB_LOG_LEVEL) ?? DEFAULT_LOG_LEVEL,
 };

package/dist/core/db.d.ts

@@ -1,5 +1,5 @@
 import { DatabaseSync, type StatementSync } from 'node:sqlite';
-import type { Memory, SearchResult } from '../types.js';
+import { type Memory, type SearchResult } from '../types.js';
 export type DbRow = Record<string, unknown>;
 export declare const db: DatabaseSync;
 export declare const closeDb: () => void;

package/dist/core/db.js

@@ -2,6 +2,7 @@ import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { config } from '../config.js';
+import { MEMORY_TYPES, } from '../types.js';
 const SCHEMA_SQL = `
   PRAGMA journal_mode = WAL;
   PRAGMA synchronous = NORMAL;
@@ -227,6 +228,14 @@ const toString = (value, field) => {
         return value;
     throw createFieldError(field);
 };
+const isMemoryType = (value) => MEMORY_TYPES.includes(value);
+const toMemoryType = (value, field) => {
+    const str = toString(value, field);
+    if (!isMemoryType(str)) {
+        throw createFieldError(field);
+    }
+    return str;
+};
 const toOptionalString = (value, field) => {
     if (value === null || value === undefined)
         return undefined;
@@ -241,6 +250,8 @@ export const mapRowToMemory = (row) => ({
     id: toSafeInteger(row.id, 'id'),
     content: toString(row.content, 'content'),
     summary: toOptionalString(row.summary, 'summary'),
+    importance: toSafeInteger(row.importance ?? 0, 'importance'),
+    memory_type: toMemoryType(row.memory_type ?? 'general', 'memory_type'),
     created_at: toString(row.created_at, 'created_at'),
     accessed_at: toString(row.accessed_at, 'accessed_at'),
     hash: toString(row.hash, 'hash'),

package/dist/core/memory-read.js

@@ -1,4 +1,4 @@
-import { db, executeGet, executeRun, mapRowToMemory, toSafeInteger, } from './db.js';
+import { db, executeGet, executeRun, mapRowToMemory, toSafeInteger, withImmediateTransaction, } from './db.js';
 const stmtGetMemoryByHash = db.prepare('SELECT * FROM memories WHERE hash = ?');
 const stmtDeleteMemoryByHash = db.prepare('DELETE FROM memories WHERE hash = ?');
 export const getMemory = (hash) => {
@@ -13,25 +13,27 @@ export const deleteMemories = (hashes) => {
     const results = [];
     let succeeded = 0;
     let failed = 0;
-    for (const hash of hashes) {
-        try {
-            const result = deleteMemory(hash);
-            if (result.changes > 0) {
-                results.push({ hash, deleted: true });
-                succeeded++;
+    return withImmediateTransaction(() => {
+        for (const hash of hashes) {
+            try {
+                const result = deleteMemory(hash);
+                if (result.changes > 0) {
+                    results.push({ hash, deleted: true });
+                    succeeded++;
+                }
+                else {
+                    results.push({ hash, deleted: false, error: 'Memory not found' });
+                    failed++;
+                }
             }
-            else {
-                results.push({ hash, deleted: false, error: 'Memory not found' });
+            catch (err) {
+                const message = err instanceof Error ? err.message : 'Unknown error';
+                results.push({ hash, deleted: false, error: message });
                 failed++;
             }
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            results.push({ hash, deleted: false, error: message });
-            failed++;
-        }
-    }
-    return { results, succeeded, failed };
+        return { results, succeeded, failed };
+    });
 };
 const stmtMemoryCount = db.prepare('SELECT COUNT(*) as count FROM memories');
 const stmtTagCount = db.prepare('SELECT COUNT(DISTINCT tag) as count FROM tags');

package/dist/core/memory-write.d.ts

@@ -1,11 +1,15 @@
-import type { BatchStoreResult, MemoryInsertResult, MemoryUpdateResult } from '../types.js';
+import type { BatchStoreResult, MemoryInsertResult, MemoryType, MemoryUpdateResult } from '../types.js';
 export declare const createMemory: (input: {
     content: string;
     tags?: readonly string[];
+    importance?: number;
+    memory_type?: MemoryType;
 }) => MemoryInsertResult;
 export declare const createMemories: (items: {
     content: string;
     tags?: readonly string[];
+    importance?: number;
+    memory_type?: MemoryType;
 }[]) => BatchStoreResult;
 interface UpdateMemoryOptions {
     content: string;

package/dist/core/memory-write.js

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import { db, executeGet, executeRun, toSafeInteger, withImmediateTransaction, } from './db.js';
 const MAX_TAGS = 100;
+const TAG_PATTERN = /^\S+$/;
 const validateTag = (tag) => {
     if (tag.length === 0) {
         throw new Error('Tag must be at least 1 character');
@@ -8,6 +9,9 @@ const validateTag = (tag) => {
     if (tag.length > 50) {
         throw new Error('Tag exceeds 50 characters');
     }
+    if (!TAG_PATTERN.test(tag)) {
+        throw new Error('Tag must not contain whitespace');
+    }
 };
 const validateTagCount = (tags, maxTags) => {
     if (tags.length > maxTags) {
@@ -60,49 +64,56 @@ const buildHash = (content) => {
     // eslint-disable-next-line sonarjs/hashing -- MD5 used for non-security deduplication only.
     return crypto.createHash('md5').update(content).digest('hex');
 };
-const stmtInsertMemory = db.prepare('INSERT OR IGNORE INTO memories (content, hash) VALUES (?, ?) RETURNING id');
+const stmtInsertMemory = db.prepare('INSERT OR IGNORE INTO memories (content, hash, importance, memory_type) VALUES (?, ?, ?, ?) RETURNING id');
 const requireMemoryId = (id) => {
     if (id === undefined) {
         throw new Error('Failed to resolve memory id');
     }
     return id;
 };
-const resolveMemoryId = (content, hash) => {
-    const inserted = executeGet(stmtInsertMemory, content, hash);
+const resolveMemoryId = (content, hash, importance, memoryType) => {
+    const inserted = executeGet(stmtInsertMemory, content, hash, importance, memoryType);
     if (inserted) {
         return { id: toSafeInteger(inserted.id, 'id'), isNew: true };
     }
     const id = requireMemoryId(findMemoryIdByHash(hash));
     return { id, isNew: false };
 };
-export const createMemory = (input) => withImmediateTransaction(() => {
-    const { content, tags = [] } = input;
+export const createMemory = (input) => withImmediateTransaction(() => createMemoryInTransaction(input));
+const createMemoryInTransaction = (input) => {
+    const { content, tags = [], importance = 0, memory_type: memoryType = 'general', } = input;
     const hash = buildHash(content);
     const normalizedTags = normalizeTags(tags, MAX_TAGS);
-    const { id, isNew } = resolveMemoryId(content, hash);
+    const { id, isNew } = resolveMemoryId(content, hash, importance, memoryType);
     insertTags(id, normalizedTags);
     return { id, hash, isNew };
-});
+};
 export const createMemories = (items) => {
     const results = [];
     let succeeded = 0;
     let failed = 0;
-    for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        if (!item)
-            continue;
-        try {
-            const { hash, isNew } = createMemory(item);
-            results.push({ index: i, hash, isNew });
-            succeeded++;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            results.push({ index: i, error: message });
-            failed++;
+    return withImmediateTransaction(() => {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (!item)
+                continue;
+            db.exec('SAVEPOINT mem_item');
+            try {
+                const { hash, isNew } = createMemoryInTransaction(item);
+                results.push({ ok: true, index: i, hash, isNew });
+                succeeded++;
+                db.exec('RELEASE mem_item');
+            }
+            catch (err) {
+                db.exec('ROLLBACK TO mem_item');
+                db.exec('RELEASE mem_item');
+                const message = err instanceof Error ? err.message : 'Unknown error';
+                results.push({ ok: false, index: i, error: message });
+                failed++;
+            }
         }
-    }
-    return { results, succeeded, failed };
+        return { results, succeeded, failed };
+    });
 };
 const stmtDeleteTagsForMemory = db.prepare('DELETE FROM tags WHERE memory_id = ?');
 const stmtUpdateContent = db.prepare('UPDATE memories SET content = ?, hash = ? WHERE id = ?');

package/dist/core/relationships.d.ts

@@ -0,0 +1,15 @@
+import type { CreateRelationshipResult, Relationship, StatementResult } from '../types.js';
+export declare const createRelationship: (input: {
+    from_hash: string;
+    to_hash: string;
+    relation_type: string;
+}) => CreateRelationshipResult;
+export declare const getRelationships: (input: {
+    hash: string;
+    direction?: "outgoing" | "incoming" | "both";
+}) => Relationship[];
+export declare const deleteRelationship: (input: {
+    from_hash: string;
+    to_hash: string;
+    relation_type: string;
+}) => StatementResult;

package/dist/core/relationships.js

@@ -0,0 +1,93 @@
+import { db, executeAll, executeGet, executeRun, toSafeInteger, withImmediateTransaction, } from './db.js';
+const stmtFindMemoryIdByHash = db.prepare('SELECT id FROM memories WHERE hash = ?');
+const findMemoryIdByHash = (hash) => {
+    const row = executeGet(stmtFindMemoryIdByHash, hash);
+    if (!row)
+        return undefined;
+    return toSafeInteger(row.id, 'id');
+};
+const requireMemoryId = (hash) => {
+    const id = findMemoryIdByHash(hash);
+    if (id === undefined) {
+        throw new Error(`Memory not found: ${hash}`);
+    }
+    return id;
+};
+const toString = (value, field) => {
+    if (typeof value === 'string')
+        return value;
+    throw new Error(`Invalid ${field}`);
+};
+const mapRowToRelationship = (row) => ({
+    id: toSafeInteger(row.id, 'id'),
+    from_hash: toString(row.from_hash, 'from_hash'),
+    to_hash: toString(row.to_hash, 'to_hash'),
+    relation_type: toString(row.relation_type, 'relation_type'),
+    created_at: toString(row.created_at, 'created_at'),
+});
+const stmtInsertRelationship = db.prepare(`
+  INSERT OR IGNORE INTO relationships (from_memory_id, to_memory_id, relation_type)
+  VALUES (?, ?, ?)
+  RETURNING id
+`);
+const stmtFindRelationshipId = db.prepare(`
+  SELECT id FROM relationships
+  WHERE from_memory_id = ? AND to_memory_id = ? AND relation_type = ?
+`);
+export const createRelationship = (input) => withImmediateTransaction(() => {
+    const fromId = requireMemoryId(input.from_hash);
+    const toId = requireMemoryId(input.to_hash);
+    if (fromId === toId) {
+        throw new Error('Cannot create self-referential relationship');
+    }
+    const inserted = executeGet(stmtInsertRelationship, fromId, toId, input.relation_type);
+    if (inserted) {
+        return { id: toSafeInteger(inserted.id, 'id'), isNew: true };
+    }
+    // Relationship already exists, find its ID
+    const existing = executeGet(stmtFindRelationshipId, fromId, toId, input.relation_type);
+    if (!existing) {
+        throw new Error('Failed to resolve relationship id');
+    }
+    return { id: toSafeInteger(existing.id, 'id'), isNew: false };
+});
+// Query that joins with memories to get hashes instead of IDs
+const buildGetRelationshipsQuery = (direction) => {
+    const baseSelect = `
+    SELECT r.id, r.relation_type, r.created_at,
+           mf.hash as from_hash, mt.hash as to_hash
+    FROM relationships r
+    JOIN memories mf ON r.from_memory_id = mf.id
+    JOIN memories mt ON r.to_memory_id = mt.id
+  `;
+    switch (direction) {
+        case 'outgoing':
+            return `${baseSelect} WHERE mf.hash = ?`;
+        case 'incoming':
+            return `${baseSelect} WHERE mt.hash = ?`;
+        case 'both':
+            return `${baseSelect} WHERE mf.hash = ? OR mt.hash = ?`;
+    }
+};
+const stmtGetRelationships = {
+    outgoing: db.prepare(buildGetRelationshipsQuery('outgoing')),
+    incoming: db.prepare(buildGetRelationshipsQuery('incoming')),
+    both: db.prepare(buildGetRelationshipsQuery('both')),
+};
+export const getRelationships = (input) => {
+    const direction = input.direction ?? 'both';
+    const stmt = stmtGetRelationships[direction];
+    const params = direction === 'both' ? [input.hash, input.hash] : [input.hash];
+    const rows = executeAll(stmt, ...params);
+    return rows.map(mapRowToRelationship);
+};
+const stmtDeleteRelationship = db.prepare(`
+  DELETE FROM relationships
+  WHERE from_memory_id = (SELECT id FROM memories WHERE hash = ?)
+    AND to_memory_id = (SELECT id FROM memories WHERE hash = ?)
+    AND relation_type = ?
+`);
+export const deleteRelationship = (input) => {
+    const result = executeRun(stmtDeleteRelationship, input.from_hash, input.to_hash, input.relation_type);
+    return { changes: toSafeInteger(result.changes, 'changes') };
+};

package/dist/core/search.d.ts

@@ -1,6 +1,10 @@
-import type { SearchResult } from '../types.js';
+import type { RecallResult, SearchResult } from '../types.js';
 interface SearchInput {
     query: string;
 }
 export declare const searchMemories: (input: SearchInput) => SearchResult[];
+export declare const recallMemories: (input: {
+    query: string;
+    depth?: number;
+}) => RecallResult;
 export {};

package/dist/core/search.js

@@ -1,6 +1,8 @@
-import { executeAll, mapRowToSearchResult, prepareCached, } from './db.js';
+import { db, executeAll, mapRowToSearchResult, prepareCached, toSafeInteger, } from './db.js';
 const MAX_QUERY_TOKENS = 50;
 const DEFAULT_LIMIT = 100;
+const RECENCY_DECAY_DAYS = 7;
+const RECENCY_WEIGHT = 0.15;
 const tokenizeQuery = (query) => {
     const parts = query
         .trim()
@@ -22,31 +24,31 @@ const buildFtsQuery = (tokens) => {
 const buildTagPlaceholders = (count) => {
     return Array.from({ length: count }, () => '?').join(', ');
 };
-// Search both content (FTS) and tags, deduplicated by memory id
 const buildSearchQuery = (tokens) => {
     const ftsQuery = buildFtsQuery(tokens);
     const tagPlaceholders = buildTagPlaceholders(tokens.length);
     const relevanceExpr = '1.0 / (1.0 + abs(bm25(memories_fts)))';
+    const recencyBoost = `MAX(0.0, (${RECENCY_DECAY_DAYS}.0 - julianday('now') + julianday(created_at)) / ${RECENCY_DECAY_DAYS}.0) * ${RECENCY_WEIGHT}`;
     // Union of FTS content matches and tag matches, deduplicated
     const sql = `
     WITH content_matches AS (
-      SELECT m.*, ${relevanceExpr} as relevance
+      SELECT m.*, ${relevanceExpr} as base_relevance, ${recencyBoost} as recency_bonus
       FROM memories m
       JOIN memories_fts ON m.id = memories_fts.rowid
       WHERE memories_fts MATCH ?
     ),
     tag_matches AS (
-      SELECT DISTINCT m.*, 0.5 as relevance
+      SELECT DISTINCT m.*, 0.5 as base_relevance, ${recencyBoost} as recency_bonus
       FROM memories m
       JOIN tags t ON m.id = t.memory_id
       WHERE t.tag IN (${tagPlaceholders})
     ),
     combined AS (
-      SELECT * FROM content_matches
+      SELECT *, (base_relevance + recency_bonus) as relevance FROM content_matches
       UNION ALL
-      SELECT * FROM tag_matches
+      SELECT *, (base_relevance + recency_bonus) as relevance FROM tag_matches
     )
-    SELECT id, content, summary, created_at, accessed_at, hash,
+    SELECT id, content, summary, importance, memory_type, created_at, accessed_at, hash,
            MAX(relevance) as relevance
     FROM combined
     GROUP BY id
@@ -107,3 +109,87 @@ export const searchMemories = (input) => {
     const rows = executeSearch(sql, params);
     return rows.map((row) => mapRowToSearchResult(row));
 };
+const MAX_RECALL_DEPTH = 3;
+const MAX_RECALL_MEMORIES = 50;
+const toString = (value, field) => {
+    if (typeof value === 'string')
+        return value;
+    throw new Error(`Invalid ${field}`);
+};
+const mapRowToRelationship = (row) => ({
+    id: toSafeInteger(row.id, 'id'),
+    from_hash: toString(row.from_hash, 'from_hash'),
+    to_hash: toString(row.to_hash, 'to_hash'),
+    relation_type: toString(row.relation_type, 'relation_type'),
+    created_at: toString(row.created_at, 'created_at'),
+});
+const buildRecallQuery = (seedCount, depth) => {
+    const seedPlaceholders = Array.from({ length: seedCount }, () => '?').join(', ');
+    const safeDepth = Math.min(Math.max(0, depth), MAX_RECALL_DEPTH);
+    const sql = `
+    WITH RECURSIVE connected(memory_id, depth) AS (
+      -- Seed memories from search results
+      SELECT id, 0 FROM memories WHERE id IN (${seedPlaceholders})
+      UNION
+      -- Follow relationships (both directions) up to max depth
+      SELECT 
+        CASE 
+          WHEN r.from_memory_id = c.memory_id THEN r.to_memory_id
+          ELSE r.from_memory_id
+        END,
+        c.depth + 1
+      FROM relationships r
+      JOIN connected c ON (r.from_memory_id = c.memory_id OR r.to_memory_id = c.memory_id)
+      WHERE c.depth < ${safeDepth}
+    ),
+    unique_memories AS (
+      SELECT DISTINCT memory_id, MIN(depth) as min_depth
+      FROM connected
+      GROUP BY memory_id
+      ORDER BY min_depth
+      LIMIT ${MAX_RECALL_MEMORIES}
+    )
+    SELECT m.*, 1.0 / (1.0 + um.min_depth) as relevance
+    FROM memories m
+    JOIN unique_memories um ON m.id = um.memory_id
+    ORDER BY um.min_depth, m.created_at DESC
+  `;
+    return { sql };
+};
+const buildRelationshipsQuery = (memoryCount) => {
+    const placeholders = Array.from({ length: memoryCount }, () => '?').join(', ');
+    const sql = `
+    SELECT r.id, r.relation_type, r.created_at,
+           mf.hash as from_hash, mt.hash as to_hash
+    FROM relationships r
+    JOIN memories mf ON r.from_memory_id = mf.id
+    JOIN memories mt ON r.to_memory_id = mt.id
+    WHERE r.from_memory_id IN (${placeholders})
+      AND r.to_memory_id IN (${placeholders})
+  `;
+    return { sql };
+};
+export const recallMemories = (input) => {
+    const depth = input.depth ?? 1;
+    const searchResults = searchMemories({ query: input.query });
+    if (searchResults.length === 0) {
+        return { memories: [], relationships: [], depth };
+    }
+    if (depth === 0) {
+        return { memories: searchResults, relationships: [], depth };
+    }
+    const seedIds = searchResults.map((m) => m.id);
+    const { sql: recallSql } = buildRecallQuery(seedIds.length, depth);
+    const recallStmt = db.prepare(recallSql);
+    const recallRows = executeAll(recallStmt, ...seedIds);
+    const memories = recallRows.map(mapRowToSearchResult);
+    const allMemoryIds = memories.map((m) => m.id);
+    if (allMemoryIds.length === 0) {
+        return { memories: [], relationships: [], depth };
+    }
+    const { sql: relSql } = buildRelationshipsQuery(allMemoryIds.length);
+    const relStmt = db.prepare(relSql);
+    const relRows = executeAll(relStmt, ...allMemoryIds, ...allMemoryIds);
+    const relationships = relRows.map(mapRowToRelationship);
+    return { memories, relationships, depth };
+};

package/dist/index.js

@@ -2,11 +2,11 @@
 import { readFile } from 'node:fs/promises';
 import process from 'node:process';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
 import { closeDb } from './core/db.js';
 import { logger } from './logger.js';
 import { ProtocolVersionGuardTransport } from './protocol-version-guard.js';
+import { BatchRejectingStdioServerTransport } from './stdio-transport.js';
 import { registerAllTools } from './tools.js';
 const readPackageVersion = async () => {
     const packageJsonText = await readFile(new URL('../package.json', import.meta.url), {
@@ -25,8 +25,11 @@ const server = new McpServer({ name: 'memdb', version: packageVersion ?? '0.0.0'
     capabilities: { tools: {} },
 });
 const patchToolErrorResults = (target) => {
-    const patched = target;
-    patched.createToolError = (message) => {
+    const targetUnknown = target;
+    const existing = Reflect.get(targetUnknown, 'createToolError');
+    if (existing !== undefined && typeof existing !== 'function')
+        return;
+    const createToolError = (message) => {
         const structured = {
             ok: false,
             error: { code: 'E_TOOL_ERROR', message },
@@ -37,6 +40,7 @@ const patchToolErrorResults = (target) => {
             isError: true,
         };
     };
+    Reflect.set(targetUnknown, 'createToolError', createToolError);
 };
 patchToolErrorResults(server);
 registerAllTools(server);
@@ -66,7 +70,7 @@ async function shutdown(signal) {
 }
 const main = async () => {
     try {
-        const stdioTransport = new StdioServerTransport();
+        const stdioTransport = new BatchRejectingStdioServerTransport();
         const guardedTransport = new ProtocolVersionGuardTransport(stdioTransport, SUPPORTED_PROTOCOL_VERSIONS);
         transport = guardedTransport;
         await server.connect(guardedTransport);

package/dist/protocol-version-guard.js

@@ -1,6 +1,19 @@
 import { isInitializedNotification, isInitializeRequest, isJSONRPCErrorResponse, isJSONRPCRequest, isJSONRPCResultResponse, } from '@modelcontextprotocol/sdk/types.js';
 const buildUnsupportedVersionMessage = (version, supportedVersions) => `Unsupported protocol version: ${version} (supported versions: ${supportedVersions.join(', ')})`;
 const isObject = (value) => typeof value === 'object' && value !== null;
+const rejectBatchIfPresent = (message, inner) => {
+    if (!Array.isArray(message))
+        return false;
+    for (const item of message) {
+        if (!isObject(item))
+            continue;
+        const id = Reflect.get(item, 'id');
+        if (typeof id !== 'string' && typeof id !== 'number')
+            continue;
+        void inner.send(createLifecycleError(id, 'Invalid request: JSON-RPC batching is not supported'), { relatedRequestId: id });
+    }
+    return true;
+};
 const getInitializeInfo = (message) => {
     if (!isInitializeRequest(message))
         return undefined;
@@ -64,6 +77,9 @@ export class ProtocolVersionGuardTransport {
         await this.inner.close();
     }
     handleMessage(message, extra) {
+        if (rejectBatchIfPresent(message, this.inner)) {
+            return;
+        }
         const initializeInfo = getInitializeInfo(message);
         if (initializeInfo) {
             if (this.sawInitialize) {

package/dist/schemas.d.ts

@@ -2,11 +2,33 @@ import { z } from 'zod';
 export declare const StoreMemoryInputSchema: z.ZodObject<{
     content: z.ZodString;
     tags: z.ZodArray<z.ZodString>;
+    importance: z.ZodOptional<z.ZodNumber>;
+    memory_type: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        general: "general";
+        fact: "fact";
+        plan: "plan";
+        decision: "decision";
+        reflection: "reflection";
+        lesson: "lesson";
+        gradient: "gradient";
+    }>>;
 }, z.core.$strict>;
 export declare const StoreMemoriesInputSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         content: z.ZodString;
         tags: z.ZodArray<z.ZodString>;
+        importance: z.ZodOptional<z.ZodNumber>;
+        memory_type: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            general: "general";
+            fact: "fact";
+            plan: "plan";
+            decision: "decision";
+            reflection: "reflection";
+            lesson: "lesson";
+            gradient: "gradient";
+        }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const SearchMemoriesInputSchema: z.ZodObject<{
@@ -27,6 +49,28 @@ export declare const UpdateMemoryInputSchema: z.ZodObject<{
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export declare const MemoryStatsInputSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const CreateRelationshipInputSchema: z.ZodObject<{
+    from_hash: z.ZodString;
+    to_hash: z.ZodString;
+    relation_type: z.ZodString;
+}, z.core.$strict>;
+export declare const GetRelationshipsInputSchema: z.ZodObject<{
+    hash: z.ZodString;
+    direction: z.ZodOptional<z.ZodEnum<{
+        outgoing: "outgoing";
+        incoming: "incoming";
+        both: "both";
+    }>>;
+}, z.core.$strict>;
+export declare const DeleteRelationshipInputSchema: z.ZodObject<{
+    from_hash: z.ZodString;
+    to_hash: z.ZodString;
+    relation_type: z.ZodString;
+}, z.core.$strict>;
+export declare const RecallInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    depth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
 export declare const DefaultOutputSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     result: z.ZodOptional<z.ZodUnknown>;