@j0hanz/memory-mcp 1.5.0 → 1.7.0

package/dist/tools/retrieve-context.js

@@ -1,13 +1,11 @@
-import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { E_CANCELLED, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
-import { sanitizeFtsQuery } from '../lib/search.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
+import { throwIfAborted } from '../lib/errors.js';
+import { buildAndWhereClause, buildFilterClauses, sanitizeFtsQuery, toMemoryFilters, } from '../lib/search.js';
+import { createToolResponse } from '../lib/tool-response.js';
 import { parseMemoryRow } from '../lib/types.js';
-import { RetrieveContextInputSchema } from '../schemas/inputs.js';
-import { RetrieveContextResultSchema } from '../schemas/outputs.js';
-import { createProgressReporter, notifyProgress, progressWithMessage, } from './progress.js';
+import {} from '../schemas/inputs.js';
+import { createProgressReporter, notifyProgress, progressWithMessage, runWithProgressCompletion, } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
-import { countPayloadArrayItems, getToolResultPayload, getToolResultText, isOkStructuredToolResult, } from './result.js';
+import { countPayloadArrayItems, formatToolCompletionMessage, } from './result.js';
 const MIN_CANDIDATE_ROWS = 200;
 const MAX_CANDIDATE_ROWS = 2000;
 const ESTIMATED_CHARS_PER_TOKEN = 4;
@@ -25,15 +23,18 @@ function countPayloadMemories(payload) {
 function estimateTokens(content) {
     return Math.ceil(content.length / ESTIMATED_CHARS_PER_TOKEN);
 }
-function loadContextRows(db, query, orderBy, limit) {
+function loadContextRows(db, query, strategy, limit, filters) {
     const ftsQuery = sanitizeFtsQuery(query);
+    const filter = buildFilterClauses(filters);
+    const whereExtra = buildAndWhereClause(filter.clauses);
+    const orderBy = ORDER_BY_MAP[strategy];
     return db
         .prepareOnce(`SELECT m.*, memories_fts.rank AS rank FROM memories m
        JOIN memories_fts ON memories_fts.rowid = m.rowid
-       WHERE memories_fts MATCH ?
+       WHERE memories_fts MATCH ?${whereExtra}
        ORDER BY ${orderBy}
        LIMIT ?`)
-        .all(ftsQuery, limit + 1);
+        .all(ftsQuery, ...filter.params, limit + 1);
 }
 function reportSelectionProgress(onProgress, current, total, force = false) {
     if (!onProgress || current === 0) {
@@ -45,108 +46,89 @@ function reportSelectionProgress(onProgress, current, total, force = false) {
     onProgress({ current, total });
 }
 function formatCompletionMessage(query, result) {
-    const failedMessage = `⊙ retrieve_context: ${query} • failed`;
-    if (result.isError) {
-        const text = getToolResultText(result);
-        if (text.includes(E_CANCELLED)) {
-            return `⊙ retrieve_context: ${query} • cancelled`;
+    return formatToolCompletionMessage('retrieve_context', query, result, (payload) => {
+        const memoriesCount = countPayloadMemories(payload);
+        const estimatedTokens = 'estimated_tokens' in payload &&
+            typeof payload.estimated_tokens === 'number'
+            ? payload.estimated_tokens
+            : 0;
+        const truncated = 'truncated' in payload && payload.truncated === true
+            ? ' [truncated]'
+            : '';
+        return `${memoriesCount} memories, ${estimatedTokens} tokens${truncated}`;
+    });
+}
+function computeCandidateLimit(tokenBudget) {
+    const estimatedCandidates = Math.ceil(tokenBudget / ESTIMATED_TOKENS_PER_MEMORY);
+    return Math.min(Math.max(MIN_CANDIDATE_ROWS, estimatedCandidates), MAX_CANDIDATE_ROWS);
+}
+function selectMemoriesWithinBudget(rows, candidateCount, tokenBudget, completionCurrent, signal, onProgress) {
+    let estimatedTokens = 0;
+    let truncated = rows.length > candidateCount;
+    const selected = [];
+    let scanned = 0;
+    for (let i = 0; i < candidateCount; i += 1) {
+        throwIfAborted(signal);
+        const row = rows[i];
+        if (!row) {
+            break;
         }
-        return failedMessage;
-    }
-    if (!isOkStructuredToolResult(result)) {
-        return failedMessage;
-    }
-    const payload = getToolResultPayload(result);
-    if (!payload) {
-        return `⊙ retrieve_context: ${query} • completed`;
+        const memory = parseMemoryRow(row);
+        const tokens = estimateTokens(memory.content);
+        scanned += 1;
+        reportSelectionProgress(onProgress, scanned, completionCurrent, false);
+        if (estimatedTokens + tokens > tokenBudget) {
+            truncated = true;
+            break;
+        }
+        estimatedTokens += tokens;
+        selected.push(memory);
     }
-    const memoriesCount = countPayloadMemories(payload);
-    const estimatedTokens = 'estimated_tokens' in payload &&
-        typeof payload.estimated_tokens === 'number'
-        ? payload.estimated_tokens
-        : 0;
-    const truncated = 'truncated' in payload && payload.truncated === true ? ' [truncated]' : '';
-    return `⊙ retrieve_context: ${query} • ${memoriesCount} memories, ${estimatedTokens} tokens${truncated}`;
+    reportSelectionProgress(onProgress, scanned, completionCurrent, true);
+    return { selected, estimatedTokens, truncated };
 }
-function throwIfAborted(signal) {
-    if (!signal?.aborted) {
-        return;
-    }
-    throw new Error(E_CANCELLED);
+function toRetrieveContextResponse(computation) {
+    const { selection } = computation;
+    return createToolResponse({
+        memories: selection.selected,
+        estimated_tokens: selection.estimatedTokens,
+        truncated: selection.truncated,
+    });
+}
+function computeRetrieveContextResult(db, params, limit, signal, onProgress) {
+    const filters = toMemoryFilters(params);
+    const rows = loadContextRows(db, params.query, params.strategy, limit, filters);
+    const rowCapExceeded = rows.length > limit;
+    const candidateCount = rowCapExceeded ? limit : rows.length;
+    const completionCurrent = candidateCount + 1;
+    return {
+        selection: selectMemoriesWithinBudget(rows, candidateCount, params.token_budget, completionCurrent, signal, onProgress),
+        completionCurrent,
+    };
 }
 export function registerRetrieveContext(server, db) {
-    registerToolWithContract(server, 'retrieve_context', RetrieveContextInputSchema, RetrieveContextResultSchema, async (params, extra) => {
+    registerToolWithContract(server, 'retrieve_context', async (params, extra) => {
         const { query, strategy } = params;
         const tokenBudget = params.token_budget;
         const contextLabel = `⊙ retrieve_context: ${query} [${strategy}]`;
         let completionCurrent = 1;
-        // Heuristic: Load enough candidates to likely fill the budget, but cap to avoid massive queries
-        const estimatedCandidates = Math.ceil(tokenBudget / ESTIMATED_TOKENS_PER_MEMORY);
-        const limit = Math.min(Math.max(MIN_CANDIDATE_ROWS, estimatedCandidates), MAX_CANDIDATE_ROWS);
+        // Heuristic: Load enough candidates to likely fill the budget, but cap to avoid massive queries.
+        const limit = computeCandidateLimit(tokenBudget);
         await notifyProgress(extra, {
             current: 0,
             message: `${contextLabel} [budget ${tokenBudget}]`,
         });
         const loopProgress = progressWithMessage(createProgressReporter(extra), ({ current, total }) => `${contextLabel} [scan ${current}/${Math.max((total ?? current) - 1, current)}]`);
-        let result;
-        let thrownError;
-        try {
+        return runWithProgressCompletion(extra, () => {
             throwIfAborted(extra.signal);
-            const orderBy = ORDER_BY_MAP[strategy];
-            const rows = loadContextRows(db, query, orderBy, limit);
-            const rowCapExceeded = rows.length > limit;
-            const candidateCount = rowCapExceeded ? limit : rows.length;
-            completionCurrent = candidateCount + 1;
-            let estimatedTokens = 0;
-            let truncated = rowCapExceeded;
-            const selected = [];
-            let scanned = 0;
-            for (let i = 0; i < candidateCount; i += 1) {
-                throwIfAborted(extra.signal);
-                const row = rows[i];
-                if (row === undefined) {
-                    break;
-                }
-                const mem = parseMemoryRow(row);
-                const tokens = estimateTokens(mem.content);
-                scanned += 1;
-                reportSelectionProgress(loopProgress, scanned, completionCurrent, false);
-                if (estimatedTokens + tokens > tokenBudget) {
-                    truncated = true;
-                    break;
-                }
-                estimatedTokens += tokens;
-                selected.push(mem);
-            }
-            reportSelectionProgress(loopProgress, scanned, completionCurrent, true);
-            result = createToolResponse({
-                memories: selected,
-                estimated_tokens: estimatedTokens,
-                truncated,
-            });
-        }
-        catch (err) {
-            if (err instanceof Error && err.message === E_CANCELLED) {
-                result = createErrorResponse(E_CANCELLED, 'Request cancelled');
-            }
-            else if (err instanceof McpError) {
-                thrownError = err;
-            }
-            else {
-                rethrowMcpError(err);
-                result = createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-            }
-        }
-        await loopProgress.flush();
-        const completionResult = result ?? createErrorResponse(E_UNKNOWN, getErrorMessage(thrownError));
-        await notifyProgress(extra, {
-            current: completionCurrent,
-            total: completionCurrent,
-            message: formatCompletionMessage(query, completionResult),
+            const computation = computeRetrieveContextResult(db, params, limit, extra.signal, loopProgress);
+            const { completionCurrent: nextCompletionCurrent } = computation;
+            completionCurrent = nextCompletionCurrent;
+            return toRetrieveContextResponse(computation);
+        }, {
+            reporter: loopProgress,
+            completionCurrent: () => completionCurrent,
+            completionMessage: (result) => formatCompletionMessage(query, result),
         });
-        if (thrownError) {
-            throw thrownError;
-        }
-        return completionResult;
     });
 }

package/dist/tools/search-memories.js

@@ -1,44 +1,41 @@
-import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { splitPage } from '../lib/pagination.js';
 import { buildSearchCursorScope, decodeSearchCursor, encodeSearchCursor, } from '../lib/search-cursor.js';
 import { loadRankedSearchRows, toMemoryFilters } from '../lib/search.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
 import { parseMemoryRow } from '../lib/types.js';
-import { SearchMemoriesInputSchema } from '../schemas/inputs.js';
-import { SearchResultSchema } from '../schemas/outputs.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+function buildNextCursorFromRows(scope, hasMore, pageRows) {
+    if (!hasMore || pageRows.length === 0) {
+        return undefined;
+    }
+    const lastRow = pageRows[pageRows.length - 1];
+    if (!lastRow) {
+        return undefined;
+    }
+    const rank = lastRow.rank ?? 0;
+    return encodeSearchCursor(scope, rank, lastRow.hash);
+}
 export function registerSearchMemories(server, db) {
-    registerToolWithContract(server, 'search_memories', SearchMemoriesInputSchema, SearchResultSchema, wrapToolHandler((params) => {
-        try {
-            const { limit, cursor } = params;
-            const filters = toMemoryFilters(params);
-            const scope = buildSearchCursorScope(params.query, filters);
-            const decodedCursor = cursor
-                ? decodeSearchCursor(cursor, scope)
-                : undefined;
-            const rows = loadRankedSearchRows(db, params.query, limit, decodedCursor, filters);
-            const { page: pageRows, hasMore } = splitPage(rows, limit);
-            const memories = pageRows.map(parseMemoryRow);
-            let nextCursor;
-            if (hasMore && pageRows.length > 0) {
-                const lastRow = pageRows[pageRows.length - 1];
-                if (lastRow !== undefined) {
-                    const rank = lastRow.rank ?? 0;
-                    nextCursor = encodeSearchCursor(scope, rank, lastRow.hash);
-                }
-            }
-            return createToolResponse({
-                memories,
-                total_returned: memories.length,
-                ...(nextCursor ? { nextCursor } : {}),
-            });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
+    registerToolWithContract(server, 'search_memories', wrapToolHandler((params) => executeToolSafely(() => {
+        const { limit, cursor } = params;
+        const filters = toMemoryFilters(params);
+        const scope = buildSearchCursorScope(params.query, filters);
+        const decodedCursor = cursor
+            ? decodeSearchCursor(cursor, scope)
+            : undefined;
+        const rows = loadRankedSearchRows(db, params.query, limit, decodedCursor, filters);
+        const { page: pageRows, hasMore } = splitPage(rows, limit);
+        const memories = pageRows.map(parseMemoryRow);
+        const nextCursor = buildNextCursorFromRows(scope, hasMore, pageRows);
+        return createToolResponse({
+            memories,
+            total_returned: memories.length,
+            ...(nextCursor ? { nextCursor } : {}),
+        });
+    }), {
         progressMessage: (params) => `⊙ search_memories: ${params.query} [limit ${params.limit}]`,
     }));
 }

package/dist/tools/store-memories.js

@@ -1,10 +1,9 @@
-import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { computeMemoryHash } from '../lib/hash.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { INSERT_MEMORY_SQL } from '../lib/sql.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { StoreMemoriesInputSchema } from '../schemas/inputs.js';
-import { BatchResultSchema } from '../schemas/outputs.js';
+import { executeToolSafely, summarizeBatch } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 async function notifyCreatedResources(server, items) {
@@ -14,47 +13,37 @@ async function notifyCreatedResources(server, items) {
     await Promise.allSettled(notifications);
 }
 export function registerStoreMemories(server, db) {
-    registerToolWithContract(server, 'store_memories', StoreMemoriesInputSchema, BatchResultSchema, wrapToolHandler(async (params) => {
-        try {
-            const now = new Date().toISOString();
-            const results = db.transaction(() => {
-                const items = [];
-                const stmt = db.prepareOnce(INSERT_MEMORY_SQL);
-                for (const item of params.items) {
-                    const { importance, memory_type: rawMemoryType } = item;
-                    const memoryType = rawMemoryType ?? 'general';
-                    const hash = computeMemoryHash(item.content, item.tags);
-                    const tagsJson = JSON.stringify(item.tags);
-                    const result = stmt.run(hash, item.content, tagsJson, memoryType, importance, now, now);
-                    items.push({
-                        hash,
-                        ok: true,
-                        created: result.changes > 0,
-                    });
-                }
-                return items;
-            });
-            let created = 0;
-            let succeeded = 0;
-            for (const item of results) {
-                if (item.ok)
-                    succeeded += 1;
-                if (item.created)
-                    created += 1;
+    registerToolWithContract(server, 'store_memories', wrapToolHandler(async (params) => executeToolSafely(async () => {
+        const now = new Date().toISOString();
+        const results = db.transaction(() => {
+            const items = [];
+            const stmt = db.prepareOnce(INSERT_MEMORY_SQL);
+            for (const item of params.items) {
+                const { importance, memory_type: rawMemoryType } = item;
+                const memoryType = rawMemoryType ?? 'general';
+                const hash = computeMemoryHash(item.content, item.tags);
+                const tagsJson = JSON.stringify(item.tags);
+                const result = stmt.run(hash, item.content, tagsJson, memoryType, importance, now, now);
+                items.push({
+                    hash,
+                    ok: true,
+                    created: result.changes > 0,
+                });
             }
-            const failed = results.length - succeeded;
-            await logToolEvent(server, 'store_memories', {
-                total: results.length,
-                created,
-            });
-            await notifyCreatedResources(server, results);
-            return createToolResponse({ items: results, succeeded, failed });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
+            return items;
+        });
+        const summary = summarizeBatch(results, (item) => item.created === true);
+        await logToolEvent(server, 'store_memories', {
+            total: results.length,
+            created: summary.matched,
+        });
+        await notifyCreatedResources(server, results);
+        return createToolResponse({
+            items: results,
+            succeeded: summary.succeeded,
+            failed: summary.failed,
+        });
+    }), {
         progressMessage: (params) => `⊕ store_memories: ${params.items.length} items [batch]`,
     }));
 }

package/dist/tools/store-memory.js

@@ -1,10 +1,9 @@
-import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { computeMemoryHash } from '../lib/hash.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { INSERT_MEMORY_SQL } from '../lib/sql.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { StoreMemoryInputSchema } from '../schemas/inputs.js';
-import { StoreResultSchema } from '../schemas/outputs.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 function toInsertParams(params, hash, memoryType, now) {
@@ -25,23 +24,17 @@ function insertMemory(db, params, hash, memoryType, now) {
     return insertResult.changes > 0;
 }
 export function registerStoreMemory(server, db) {
-    registerToolWithContract(server, 'store_memory', StoreMemoryInputSchema, StoreResultSchema, wrapToolHandler(async (params) => {
-        try {
-            const memoryType = params.memory_type ?? 'general';
-            const hash = computeMemoryHash(params.content, params.tags);
-            const now = new Date().toISOString();
-            const created = insertMemory(db, params, hash, memoryType, now);
-            await logToolEvent(server, 'store', { hash, created });
-            if (created) {
-                await notifyMemoryResourceUpdated(server, hash);
-            }
-            return createToolResponse({ hash, created });
+    registerToolWithContract(server, 'store_memory', wrapToolHandler(async (params) => executeToolSafely(async () => {
+        const memoryType = params.memory_type ?? 'general';
+        const hash = computeMemoryHash(params.content, params.tags);
+        const now = new Date().toISOString();
+        const created = insertMemory(db, params, hash, memoryType, now);
+        await logToolEvent(server, 'store', { hash, created });
+        if (created) {
+            await notifyMemoryResourceUpdated(server, hash);
         }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
+        return createToolResponse({ hash, created });
+    }), {
         progressMessage: (params) => `⊕ store_memory: ${params.tags.length} tags [single]`,
     }));
 }

package/dist/tools/update-memory.js

@@ -1,13 +1,14 @@
-import { E_CONFLICT, E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { E_CONFLICT, E_NOT_FOUND } from '../lib/errors.js';
 import { computeMemoryHash } from '../lib/hash.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { SELECT_MEMORY_BY_HASH_SQL, SELECT_MEMORY_HASH_SQL, } from '../lib/sql.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
 import { parseTags } from '../lib/types.js';
-import { UpdateMemoryInputSchema } from '../schemas/inputs.js';
-import { UpdateResultSchema } from '../schemas/outputs.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+import { formatHashPreview } from './result.js';
 const UPDATE_MEMORY_SQL = `UPDATE memories
   SET hash = ?, content = ?, tags = ?, updated_at = ?
   WHERE hash = ?`;
@@ -19,57 +20,52 @@ async function notifyUpdatedMemoryResources(server, oldHash, newHash) {
     await Promise.allSettled(notifications);
 }
 export function registerUpdateMemory(server, db) {
-    registerToolWithContract(server, 'update_memory', UpdateMemoryInputSchema, UpdateResultSchema, wrapToolHandler(async (params) => {
-        try {
-            // All reads and the write are inside a single IMMEDIATE transaction
-            // to prevent TOCTOU between existence/collision checks and UPDATE.
-            const txResult = db.transaction(() => {
-                const existing = db
-                    .prepareOnce(SELECT_MEMORY_BY_HASH_SQL)
-                    .get(params.hash);
-                if (!existing) {
+    registerToolWithContract(server, 'update_memory', wrapToolHandler(async (params) => executeToolSafely(async () => {
+        // All reads and the write are inside a single IMMEDIATE transaction
+        // to prevent TOCTOU between existence/collision checks and UPDATE.
+        const txResult = db.transaction(() => {
+            const existing = db
+                .prepareOnce(SELECT_MEMORY_BY_HASH_SQL)
+                .get(params.hash);
+            if (!existing) {
+                return {
+                    ok: false,
+                    code: E_NOT_FOUND,
+                    message: `Memory not found: ${params.hash}`,
+                };
+            }
+            const newContent = params.content ?? existing.content;
+            const newTags = params.tags ?? parseTags(existing.tags);
+            const newHash = computeMemoryHash(newContent, newTags);
+            if (newHash !== params.hash) {
+                const collision = db
+                    .prepareOnce(SELECT_MEMORY_HASH_SQL)
+                    .get(newHash);
+                if (collision) {
                     return {
                         ok: false,
-                        code: E_NOT_FOUND,
-                        message: `Memory not found: ${params.hash}`,
+                        code: E_CONFLICT,
+                        message: `Memory already exists for target content/tags: ${newHash}`,
                     };
                 }
-                const newTags = params.tags ?? parseTags(existing.tags);
-                const newHash = computeMemoryHash(params.content, newTags);
-                if (newHash !== params.hash) {
-                    const collision = db
-                        .prepareOnce(SELECT_MEMORY_HASH_SQL)
-                        .get(newHash);
-                    if (collision) {
-                        return {
-                            ok: false,
-                            code: E_CONFLICT,
-                            message: `Memory already exists for target content/tags: ${newHash}`,
-                        };
-                    }
-                }
-                const now = new Date().toISOString();
-                db.prepareOnce(UPDATE_MEMORY_SQL).run(newHash, params.content, JSON.stringify(newTags), now, params.hash);
-                return { ok: true, oldHash: params.hash, newHash };
-            });
-            if (!txResult.ok) {
-                return createErrorResponse(txResult.code, txResult.message);
             }
-            await logToolEvent(server, 'update', {
-                oldHash: txResult.oldHash,
-                newHash: txResult.newHash,
-            });
-            await notifyUpdatedMemoryResources(server, txResult.oldHash, txResult.newHash);
-            return createToolResponse({
-                old_hash: txResult.oldHash,
-                new_hash: txResult.newHash,
-            });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
+            const now = new Date().toISOString();
+            db.prepareOnce(UPDATE_MEMORY_SQL).run(newHash, newContent, JSON.stringify(newTags), now, params.hash);
+            return { ok: true, oldHash: params.hash, newHash };
+        });
+        if (!txResult.ok) {
+            return createErrorResponse(txResult.code, txResult.message);
         }
-    }, {
-        progressMessage: (params) => `⊜ update_memory: ${params.hash.slice(0, 12)}... [replace content]`,
+        await logToolEvent(server, 'update', {
+            oldHash: txResult.oldHash,
+            newHash: txResult.newHash,
+        });
+        await notifyUpdatedMemoryResources(server, txResult.oldHash, txResult.newHash);
+        return createToolResponse({
+            old_hash: txResult.oldHash,
+            new_hash: txResult.newHash,
+        });
+    }), {
+        progressMessage: (params) => `⊜ update_memory: ${formatHashPreview(params.hash)} [replace content]`,
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/memory-mcp",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "mcpName": "io.github.j0hanz/memory-mcp",
   "author": "Johanz",
   "license": "MIT",