@j0hanz/memory-mcp 1.4.0 → 1.6.0

package/dist/tools/progress.js

@@ -1,6 +1,10 @@
 import { E_CANCELLED } from '../lib/errors.js';
 import { getToolResultText } from './result.js';
 const DEFAULT_PROGRESS_INTERVAL_MS = 250;
+const TOOL_HANDLER_PROGRESS_TOTAL = 1;
+function hasProgressTransport(extra, progressToken) {
+    return (progressToken !== undefined && typeof extra.sendNotification === 'function');
+}
 function toProgressToken(value) {
     if (typeof value === 'string' || typeof value === 'number') {
         return value;
@@ -20,6 +24,19 @@ function toNotificationParams(progressToken, progress) {
     }
     return params;
 }
+function toProgressNotification(progressToken, progress) {
+    return {
+        method: 'notifications/progress',
+        params: toNotificationParams(progressToken, progress),
+    };
+}
+function toProgressPayload(progress, current) {
+    return {
+        current,
+        ...(progress.total !== undefined ? { total: progress.total } : {}),
+        ...(progress.message !== undefined ? { message: progress.message } : {}),
+    };
+}
 function getResultOutcome(result) {
     if (result.isError) {
         const text = getToolResultText(result);
@@ -41,14 +58,11 @@ export async function notifyProgress(extra, progress) {
     if (progressToken === undefined) {
         return;
     }
-    if (typeof extra.sendNotification !== 'function') {
+    if (!hasProgressTransport(extra, progressToken)) {
         return;
     }
     try {
-        await extra.sendNotification({
-            method: 'notifications/progress',
-            params: toNotificationParams(progressToken, progress),
-        });
+        await extra.sendNotification(toProgressNotification(progressToken, progress));
     }
     catch {
         // best-effort progress
@@ -75,13 +89,7 @@ export function createProgressReporter(extra, options = {}) {
         lastReportedAt = now;
         isCompleted =
             progress.total !== undefined && monotonicCurrent >= progress.total;
-        const payload = { current: monotonicCurrent };
-        if (progress.total !== undefined) {
-            payload.total = progress.total;
-        }
-        if (progress.message !== undefined) {
-            payload.message = progress.message;
-        }
+        const payload = toProgressPayload(progress, monotonicCurrent);
         notificationChain = notificationChain.then(() => notifyProgress(extra, payload));
     });
     reporter.flush = async () => {
@@ -102,11 +110,18 @@ export function progressWithMessage(reporter, getMessage) {
     return wrapped;
 }
 export function wrapToolHandler(handler, options) {
+    const notifyTerminalProgress = async (extra, startMessage, outcome, completionMessage) => {
+        await notifyProgress(extra, {
+            current: TOOL_HANDLER_PROGRESS_TOTAL,
+            total: TOOL_HANDLER_PROGRESS_TOTAL,
+            message: completionMessage ?? `${startMessage} • ${outcome}`,
+        });
+    };
     return async (args, extra) => {
         const startMessage = options.progressMessage(args);
         await notifyProgress(extra, {
             current: 0,
-            total: 1,
+            total: TOOL_HANDLER_PROGRESS_TOTAL,
             message: startMessage,
         });
         let result;
@@ -115,20 +130,12 @@ export function wrapToolHandler(handler, options) {
         }
         catch (error) {
             const isCancelled = error instanceof Error && error.message === E_CANCELLED;
-            await notifyProgress(extra, {
-                current: 1,
-                total: 1,
-                message: `${startMessage} • ${isCancelled ? 'cancelled' : 'failed'}`,
-            });
+            await notifyTerminalProgress(extra, startMessage, isCancelled ? 'cancelled' : 'failed');
             throw error;
         }
         const completionMessage = options.completionMessage?.(args, result) ??
             defaultCompletionMessage(startMessage, result);
-        await notifyProgress(extra, {
-            current: 1,
-            total: 1,
-            message: completionMessage,
-        });
+        await notifyTerminalProgress(extra, startMessage, 'completed', completionMessage);
         return result;
     };
 }

package/dist/tools/recall.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerRecall(server: McpServer, db: TypedDb): void;
+//# sourceMappingURL=recall.d.ts.map

package/dist/tools/recall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall.d.ts","sourceRoot":"","sources":["../../src/tools/recall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAUzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAoX9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAqFnE"}

package/dist/tools/recall.js

@@ -145,9 +145,71 @@ function formatRecallCompletionMessage(query, result) {
     const aborted = 'aborted' in payload && payload.aborted === true;
     return `⊙ recall: ${query} • ${memoriesCount} memories, ${edgesCount} edges${aborted ? ' [aborted]' : ''}`;
 }
+function decodeCursorForRecall(cursor, scope) {
+    if (!cursor) {
+        return undefined;
+    }
+    return decodeSearchCursor(cursor, scope);
+}
+function buildSeedRelevanceMap(seeds) {
+    const seedRelevance = new Map();
+    for (const seed of seeds) {
+        if (seed.rank != null) {
+            seedRelevance.set(seed.hash, -seed.rank);
+        }
+    }
+    return seedRelevance;
+}
+function toMemoriesWithRelevance(rows, seedRelevance) {
+    return rows.map((row) => {
+        const memory = parseMemoryRow(row);
+        const relevance = seedRelevance.get(memory.hash);
+        if (relevance != null) {
+            memory.relevance = relevance;
+        }
+        return memory;
+    });
+}
+function buildNextCursor(hasMore, pageSeeds, scope) {
+    if (!hasMore || pageSeeds.length === 0) {
+        return undefined;
+    }
+    const lastSeed = pageSeeds[pageSeeds.length - 1];
+    if (!lastSeed) {
+        return undefined;
+    }
+    const rank = lastSeed.rank ?? 0;
+    return encodeSearchCursor(scope, rank, lastSeed.hash);
+}
+function createHopReporter(extra, query, completionCurrent) {
+    const reporter = progressWithMessage(createProgressReporter(extra), ({ current, total }) => `⊙ recall: ${query} [hop ${current}/${Math.max((total ?? current) - 1, current)}]`);
+    const onHop = (hop) => {
+        reporter({ current: hop + 1, total: completionCurrent });
+    };
+    return { reporter, onHop };
+}
+async function computeRecall(db, params, scope, signal, onHop) {
+    const decodedCursor = decodeCursorForRecall(params.cursor, scope);
+    const seedRows = loadRankedSearchRows(db, params.query, params.limit, decodedCursor, toMemoryFilters(params));
+    const { page: pageSeeds, hasMore } = splitPage(seedRows, params.limit);
+    const traversal = await traverseGraph(db, pageSeeds, params.depth, signal, onHop);
+    const allHashes = Array.from(traversal.visited);
+    const seedRelevance = buildSeedRelevanceMap(pageSeeds);
+    const memoryRows = loadMemoriesByHashes(db, allHashes);
+    const nextCursor = buildNextCursor(hasMore, pageSeeds, scope);
+    return {
+        memories: toMemoriesWithRelevance(memoryRows, seedRelevance),
+        edges: traversal.edges,
+        depthReached: traversal.depthReached,
+        aborted: traversal.aborted,
+        ...(nextCursor ? { nextCursor } : {}),
+        seedCount: pageSeeds.length,
+        visitedCount: traversal.visited.size,
+    };
+}
 export function registerRecall(server, db) {
     registerToolWithContract(server, 'recall', RecallInputSchema, RecallResultSchema, async (params, extra) => {
-        const { depth, limit, cursor } = params;
+        const { depth } = params;
         const filters = toMemoryFilters(params);
         const scope = buildSearchCursorScope(params.query, filters);
         const contextLabel = `⊙ recall: ${params.query} [depth ${depth}]`;
@@ -157,62 +219,29 @@ export function registerRecall(server, db) {
             total: completionCurrent,
             message: contextLabel,
         });
-        const hopReporter = progressWithMessage(createProgressReporter(extra), ({ current, total }) => `⊙ recall: ${params.query} [hop ${current}/${Math.max((total ?? current) - 1, current)}]`);
-        const onHop = (hop) => {
-            hopReporter({ current: hop + 1, total: completionCurrent });
-        };
+        const { reporter: hopReporter, onHop } = createHopReporter(extra, params.query, completionCurrent);
         let result;
         let thrownError;
         try {
             throwIfAborted(extra.signal);
-            const decodedCursor = cursor
-                ? decodeSearchCursor(cursor, scope)
-                : undefined;
-            // Step 1: FTS seed search
-            const seedRows = loadRankedSearchRows(db, params.query, limit, decodedCursor, filters);
+            const computation = await computeRecall(db, params, scope, extra.signal, onHop);
             throwIfAborted(extra.signal);
-            const { page: pageSeeds, hasMore } = splitPage(seedRows, limit);
-            // Step 2: BFS traversal up to `depth` hops
-            const traversal = await traverseGraph(db, pageSeeds, depth, extra.signal, onHop);
-            throwIfAborted(extra.signal);
-            // Step 3: Load all discovered memory rows
-            const allHashes = Array.from(traversal.visited);
-            const seedRelevance = new Map();
-            for (const seed of pageSeeds) {
-                if (seed.rank != null)
-                    seedRelevance.set(seed.hash, -seed.rank);
-            }
-            const memoryRows = loadMemoriesByHashes(db, allHashes);
-            const memories = memoryRows.map((row) => {
-                const memory = parseMemoryRow(row);
-                const rel = seedRelevance.get(memory.hash);
-                if (rel != null) {
-                    memory.relevance = rel;
-                }
-                return memory;
-            });
-            let nextCursor;
-            if (hasMore && pageSeeds.length > 0) {
-                const lastSeed = pageSeeds[pageSeeds.length - 1];
-                if (lastSeed !== undefined) {
-                    const rank = lastSeed.rank ?? 0;
-                    nextCursor = encodeSearchCursor(scope, rank, lastSeed.hash);
-                }
-            }
             await logToolEvent(server, 'recall', {
                 depth,
-                depth_reached: traversal.depthReached,
-                seed_count: pageSeeds.length,
-                visited_nodes: traversal.visited.size,
-                edge_count: traversal.edges.length,
-                aborted: traversal.aborted,
+                depth_reached: computation.depthReached,
+                seed_count: computation.seedCount,
+                visited_nodes: computation.visitedCount,
+                edge_count: computation.edges.length,
+                aborted: computation.aborted,
             });
             result = createToolResponse({
-                memories,
-                graph: traversal.edges,
-                depth_reached: traversal.depthReached,
-                ...(traversal.aborted ? { aborted: true } : {}),
-                ...(nextCursor ? { nextCursor } : {}),
+                memories: computation.memories,
+                graph: computation.edges,
+                depth_reached: computation.depthReached,
+                ...(computation.aborted ? { aborted: true } : {}),
+                ...(computation.nextCursor
+                    ? { nextCursor: computation.nextCursor }
+                    : {}),
             });
         }
         catch (err) {

package/dist/tools/register-contract.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { z } from 'zod/v4';
 export declare function registerToolWithContract(server: McpServer, toolName: string, _inputSchema: z.ZodType, _outputSchema: z.ZodType, handler: unknown): void;
+//# sourceMappingURL=register-contract.d.ts.map

package/dist/tools/register-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-contract.d.ts","sourceRoot":"","sources":["../../src/tools/register-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAIhC,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,CAAC,CAAC,OAAO,EACvB,aAAa,EAAE,CAAC,CAAC,OAAO,EACxB,OAAO,EAAE,OAAO,GACf,IAAI,CAcN"}

package/dist/tools/result.d.ts

@@ -5,3 +5,4 @@ export declare function getToolResultPayload(result: CallToolResult): ToolResult
 export declare function getToolResultText(result: CallToolResult): string;
 /** Count items in a named array field of a tool result payload. */
 export declare function countPayloadArrayItems(payload: Record<string, unknown>, key: string): number;
+//# sourceMappingURL=result.d.ts.map

package/dist/tools/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/tools/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAMxD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAExE;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,cAAc,GACrB,iBAAiB,GAAG,SAAS,CAO/B;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAGhE;AAED,mEAAmE;AACnE,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,MAAM,GACV,MAAM,CAGR"}

package/dist/tools/retrieve-context.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerRetrieveContext(server: McpServer, db: TypedDb): void;
+//# sourceMappingURL=retrieve-context.d.ts.map

package/dist/tools/retrieve-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieve-context.d.ts","sourceRoot":"","sources":["../../src/tools/retrieve-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAMzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AA8N9C,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CA0E5E"}

package/dist/tools/retrieve-context.js

@@ -74,15 +74,54 @@ function throwIfAborted(signal) {
     }
     throw new Error(E_CANCELLED);
 }
+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;
+        }
+        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);
+    }
+    reportSelectionProgress(onProgress, scanned, completionCurrent, true);
+    return { selected, estimatedTokens, truncated };
+}
+function computeRetrieveContextResult(db, params, limit, signal, onProgress) {
+    const orderBy = ORDER_BY_MAP[params.strategy];
+    const rows = loadContextRows(db, params.query, orderBy, limit);
+    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) => {
         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}]`,
@@ -92,37 +131,12 @@ export function registerRetrieveContext(server, db) {
         let thrownError;
         try {
             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);
+            const { selection, completionCurrent: nextCompletionCurrent } = computeRetrieveContextResult(db, params, limit, extra.signal, loopProgress);
+            completionCurrent = nextCompletionCurrent;
             result = createToolResponse({
-                memories: selected,
-                estimated_tokens: estimatedTokens,
-                truncated,
+                memories: selection.selected,
+                estimated_tokens: selection.estimatedTokens,
+                truncated: selection.truncated,
             });
         }
         catch (err) {

package/dist/tools/search-memories.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerSearchMemories(server: McpServer, db: TypedDb): void;
+//# sourceMappingURL=search-memories.d.ts.map

package/dist/tools/search-memories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-memories.d.ts","sourceRoot":"","sources":["../../src/tools/search-memories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAmB9C,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CA8C3E"}

package/dist/tools/search-memories.js

@@ -1,44 +1,38 @@
-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 { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 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);
-                }
+    registerToolWithContract(server, 'search_memories', SearchMemoriesInputSchema, SearchResultSchema, 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);
+        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));
-        }
-    }, {
+        return createToolResponse({
+            memories,
+            total_returned: memories.length,
+            ...(nextCursor ? { nextCursor } : {}),
+        });
+    }), {
         progressMessage: (params) => `⊙ search_memories: ${params.query} [limit ${params.limit}]`,
     }));
 }

package/dist/tools/store-memories.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerStoreMemories(server: McpServer, db: TypedDb): void;
+//# sourceMappingURL=store-memories.d.ts.map

package/dist/tools/store-memories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-memories.d.ts","sourceRoot":"","sources":["../../src/tools/store-memories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAwB9C,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CA2D1E"}

package/dist/tools/store-memories.js

@@ -1,8 +1,8 @@
-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 { executeToolSafely, summarizeBatch } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
 import { StoreMemoriesInputSchema } from '../schemas/inputs.js';
 import { BatchResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
@@ -14,47 +14,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', StoreMemoriesInputSchema, BatchResultSchema, 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.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerStoreMemory(server: McpServer, db: TypedDb): void;
+//# sourceMappingURL=store-memory.d.ts.map

package/dist/tools/store-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-memory.d.ts","sourceRoot":"","sources":["../../src/tools/store-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AA2C9C,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CA0BxE"}

package/dist/tools/store-memory.js

@@ -1,8 +1,8 @@
-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 { executeToolSafely } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
 import { StoreMemoryInputSchema } from '../schemas/inputs.js';
 import { StoreResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
@@ -25,23 +25,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', StoreMemoryInputSchema, StoreResultSchema, 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.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerUpdateMemory(server: McpServer, db: TypedDb): void;
+//# sourceMappingURL=update-memory.d.ts.map

package/dist/tools/update-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-memory.d.ts","sourceRoot":"","sources":["../../src/tools/update-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAyC9C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CA6EzE"}