@j0hanz/memory-mcp 1.6.0 → 1.7.0

package/dist/tools/progress.js

@@ -1,5 +1,10 @@
-import { E_CANCELLED } from '../lib/errors.js';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+import { CancelledError, E_CANCELLED, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { createErrorResponse } from '../lib/tool-response.js';
 import { getToolResultText } from './result.js';
+function resolveCompletionCurrent(value) {
+    return typeof value === 'function' ? value() : value;
+}
 const DEFAULT_PROGRESS_INTERVAL_MS = 250;
 const TOOL_HANDLER_PROGRESS_TOTAL = 1;
 function hasProgressTransport(extra, progressToken) {
@@ -129,7 +134,7 @@ export function wrapToolHandler(handler, options) {
             result = await handler(args, extra);
         }
         catch (error) {
-            const isCancelled = error instanceof Error && error.message === E_CANCELLED;
+            const isCancelled = error instanceof CancelledError;
             await notifyTerminalProgress(extra, startMessage, isCancelled ? 'cancelled' : 'failed');
             throw error;
         }
@@ -139,3 +144,34 @@ export function wrapToolHandler(handler, options) {
         return result;
     };
 }
+export async function runWithProgressCompletion(extra, run, options) {
+    let result;
+    let thrownError;
+    try {
+        result = await run();
+    }
+    catch (error) {
+        if (error instanceof CancelledError) {
+            result = createErrorResponse(E_CANCELLED, 'Request cancelled');
+        }
+        else if (error instanceof McpError) {
+            thrownError = error;
+        }
+        else {
+            rethrowMcpError(error);
+            result = createErrorResponse(E_UNKNOWN, getErrorMessage(error));
+        }
+    }
+    await options.reporter.flush();
+    const completionResult = result ?? createErrorResponse(E_UNKNOWN, getErrorMessage(thrownError));
+    const completionCurrent = resolveCompletionCurrent(options.completionCurrent);
+    await notifyProgress(extra, {
+        current: completionCurrent,
+        total: completionCurrent,
+        message: options.completionMessage(completionResult),
+    });
+    if (thrownError) {
+        throw thrownError;
+    }
+    return completionResult;
+}

package/dist/tools/recall.d.ts

@@ -1,4 +1,3 @@
 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.js

@@ -1,121 +1,16 @@
-import { McpError, } from '@modelcontextprotocol/sdk/types.js';
-import process from 'node:process';
-import { E_CANCELLED, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { throwIfAborted } from '../lib/errors.js';
+import { traverseGraph, } from '../lib/graph-traversal.js';
 import { logToolEvent } from '../lib/mcp-utils.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 { createToolResponse } from '../lib/tool-response.js';
 import { parseMemoryRow } from '../lib/types.js';
-import { RecallInputSchema } from '../schemas/inputs.js';
-import { RecallResultSchema } 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';
-function throwIfAborted(signal) {
-    if (!signal?.aborted) {
-        return;
-    }
-    throw new Error(E_CANCELLED);
-}
-function yieldToEventLoop() {
-    return new Promise((resolve) => setImmediate(resolve));
-}
-function parseEnvInt(name, fallback, min, max) {
-    const raw = process.env[name];
-    if (raw == null)
-        return fallback;
-    const parsed = parseInt(raw, 10);
-    if (Number.isNaN(parsed))
-        return fallback;
-    return Math.max(min, Math.min(max, parsed));
-}
-const MAX_FRONTIER_SIZE = parseEnvInt('RECALL_MAX_FRONTIER_SIZE', 1000, 100, 50000);
-const MAX_EDGE_ROWS = parseEnvInt('RECALL_MAX_EDGE_ROWS', 5000, 100, 50000);
-const MAX_VISITED_NODES = parseEnvInt('RECALL_MAX_VISITED_NODES', 5000, 100, 50000);
-const EDGE_QUERY_SQL = `SELECT from_hash, to_hash, relation_type FROM relationships
-         WHERE from_hash IN (SELECT value FROM json_each(?))
-            OR to_hash   IN (SELECT value FROM json_each(?))
-         LIMIT ?`;
+import { countPayloadArrayItems, formatToolCompletionMessage, } from './result.js';
 const MEMORIES_BY_HASH_SQL = 'SELECT * FROM memories WHERE hash IN (SELECT value FROM json_each(?))';
-async function traverseGraph(db, seeds, depth, signal, onHop) {
-    const visited = new Set();
-    const frontier = [];
-    for (const seed of seeds) {
-        visited.add(seed.hash);
-        frontier.push(seed.hash);
-    }
-    const edges = [];
-    const seenEdges = new Set();
-    let depthReached = 0;
-    let aborted = false;
-    const edgeStmt = db.prepareOnce(EDGE_QUERY_SQL);
-    for (let hop = 0; hop < depth && frontier.length > 0; hop += 1) {
-        // Yield to event loop to allow progress notifications and cancellation
-        await yieldToEventLoop();
-        throwIfAborted(signal);
-        depthReached = hop + 1;
-        onHop?.(hop, depth);
-        if (frontier.length > MAX_FRONTIER_SIZE) {
-            frontier.length = MAX_FRONTIER_SIZE;
-            aborted = true;
-        }
-        const remainingEdgeBudget = MAX_EDGE_ROWS - edges.length;
-        const remainingNodeBudget = MAX_VISITED_NODES - visited.size;
-        if (remainingEdgeBudget <= 0 || remainingNodeBudget <= 0) {
-            aborted = true;
-            break;
-        }
-        const frontierJson = JSON.stringify(frontier);
-        const edgeRows = edgeStmt.all(frontierJson, frontierJson, remainingEdgeBudget + 1);
-        const rowsToProcess = edgeRows.length > remainingEdgeBudget
-            ? remainingEdgeBudget
-            : edgeRows.length;
-        if (edgeRows.length > remainingEdgeBudget) {
-            aborted = true;
-        }
-        const nextHashes = [];
-        const queueVisitedHash = (hash) => {
-            if (visited.has(hash)) {
-                return;
-            }
-            if (visited.size >= MAX_VISITED_NODES) {
-                aborted = true;
-                return;
-            }
-            visited.add(hash);
-            if (nextHashes.length < MAX_FRONTIER_SIZE) {
-                nextHashes.push(hash);
-                return;
-            }
-            aborted = true;
-        };
-        for (let i = 0; i < rowsToProcess; i += 1) {
-            const edge = edgeRows[i];
-            if (edge === undefined) {
-                break;
-            }
-            const edgeKey = `${edge.from_hash}|${edge.to_hash}|${edge.relation_type}`;
-            if (!seenEdges.has(edgeKey)) {
-                seenEdges.add(edgeKey);
-                edges.push({
-                    from_hash: edge.from_hash,
-                    to_hash: edge.to_hash,
-                    relation_type: edge.relation_type,
-                });
-            }
-            queueVisitedHash(edge.from_hash);
-            queueVisitedHash(edge.to_hash);
-            if (aborted &&
-                (edges.length >= MAX_EDGE_ROWS || visited.size >= MAX_VISITED_NODES)) {
-                break;
-            }
-        }
-        frontier.length = 0;
-        frontier.push(...nextHashes);
-    }
-    return { edges, visited, depthReached, aborted };
-}
 function loadMemoriesByHashes(db, hashes) {
     if (hashes.length === 0) {
         return [];
@@ -125,25 +20,12 @@ function loadMemoriesByHashes(db, hashes) {
         .all(JSON.stringify(hashes));
 }
 function formatRecallCompletionMessage(query, result) {
-    const failedMessage = `⊙ recall: ${query} • failed`;
-    if (result.isError) {
-        const text = getToolResultText(result);
-        if (text.includes(E_CANCELLED)) {
-            return `⊙ recall: ${query} • cancelled`;
-        }
-        return failedMessage;
-    }
-    if (!isOkStructuredToolResult(result)) {
-        return failedMessage;
-    }
-    const payload = getToolResultPayload(result);
-    if (!payload) {
-        return `⊙ recall: ${query} • completed`;
-    }
-    const memoriesCount = countPayloadArrayItems(payload, 'memories');
-    const edgesCount = countPayloadArrayItems(payload, 'graph');
-    const aborted = 'aborted' in payload && payload.aborted === true;
-    return `⊙ recall: ${query} • ${memoriesCount} memories, ${edgesCount} edges${aborted ? ' [aborted]' : ''}`;
+    return formatToolCompletionMessage('recall', query, result, (payload) => {
+        const memoriesCount = countPayloadArrayItems(payload, 'memories');
+        const edgesCount = countPayloadArrayItems(payload, 'graph');
+        const aborted = 'aborted' in payload && payload.aborted === true;
+        return `${memoriesCount} memories, ${edgesCount} edges${aborted ? ' [aborted]' : ''}`;
+    });
 }
 function decodeCursorForRecall(cursor, scope) {
     if (!cursor) {
@@ -188,6 +70,15 @@ function createHopReporter(extra, query, completionCurrent) {
     };
     return { reporter, onHop };
 }
+function toRecallResponse(computation) {
+    return createToolResponse({
+        memories: computation.memories,
+        graph: computation.edges,
+        depth_reached: computation.depthReached,
+        ...(computation.aborted ? { aborted: true } : {}),
+        ...(computation.nextCursor ? { nextCursor: computation.nextCursor } : {}),
+    });
+}
 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));
@@ -208,7 +99,7 @@ async function computeRecall(db, params, scope, signal, onHop) {
     };
 }
 export function registerRecall(server, db) {
-    registerToolWithContract(server, 'recall', RecallInputSchema, RecallResultSchema, async (params, extra) => {
+    registerToolWithContract(server, 'recall', async (params, extra) => {
         const { depth } = params;
         const filters = toMemoryFilters(params);
         const scope = buildSearchCursorScope(params.query, filters);
@@ -220,9 +111,7 @@ export function registerRecall(server, db) {
             message: contextLabel,
         });
         const { reporter: hopReporter, onHop } = createHopReporter(extra, params.query, completionCurrent);
-        let result;
-        let thrownError;
-        try {
+        return runWithProgressCompletion(extra, async () => {
             throwIfAborted(extra.signal);
             const computation = await computeRecall(db, params, scope, extra.signal, onHop);
             throwIfAborted(extra.signal);
@@ -234,38 +123,11 @@ export function registerRecall(server, db) {
                 edge_count: computation.edges.length,
                 aborted: computation.aborted,
             });
-            result = createToolResponse({
-                memories: computation.memories,
-                graph: computation.edges,
-                depth_reached: computation.depthReached,
-                ...(computation.aborted ? { aborted: true } : {}),
-                ...(computation.nextCursor
-                    ? { nextCursor: computation.nextCursor }
-                    : {}),
-            });
-        }
-        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 hopReporter.flush();
-        const completionResult = result ?? createErrorResponse(E_UNKNOWN, getErrorMessage(thrownError));
-        await notifyProgress(extra, {
-            current: completionCurrent,
-            total: completionCurrent,
-            message: formatRecallCompletionMessage(params.query, completionResult),
+            return toRecallResponse(computation);
+        }, {
+            reporter: hopReporter,
+            completionCurrent,
+            completionMessage: (result) => formatRecallCompletionMessage(params.query, result),
         });
-        if (thrownError) {
-            throw thrownError;
-        }
-        return completionResult;
     });
 }

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

@@ -1,4 +1,2 @@
 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
+export declare function registerToolWithContract(server: McpServer, toolName: string, handler: unknown): void;

package/dist/tools/register-contract.js

@@ -1,5 +1,5 @@
 import { getToolContract } from '../lib/tool-contracts.js';
-export function registerToolWithContract(server, toolName, _inputSchema, _outputSchema, handler) {
+export function registerToolWithContract(server, toolName, handler) {
     const contract = getToolContract(toolName);
     server.registerTool(contract.name, {
         title: contract.title,
@@ -7,5 +7,7 @@ export function registerToolWithContract(server, toolName, _inputSchema, _output
         inputSchema: contract.inputSchema,
         outputSchema: contract.outputSchema,
         annotations: contract.annotations,
-    }, handler);
+    }, 
+    // The handler is validated at runtime and tested via contract verification
+    handler);
 }

package/dist/tools/result.d.ts

@@ -5,4 +5,7 @@ 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
+/** Standardize format of tool completion messages. */
+export declare function formatToolCompletionMessage(toolName: string, query: string, result: CallToolResult, getSuccessMessage: (payload: ToolResultPayload) => string): string;
+export declare function formatHashPreview(hash: string, length?: number): string;
+export declare function formatRelationshipPreview(fromHash: string, toHash: string, length?: number): string;

package/dist/tools/result.js

@@ -1,3 +1,4 @@
+import { E_CANCELLED } from '../lib/errors.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -20,3 +21,29 @@ export function countPayloadArrayItems(payload, key) {
     const value = payload[key];
     return Array.isArray(value) ? value.length : 0;
 }
+/** Standardize format of tool completion messages. */
+export function formatToolCompletionMessage(toolName, query, result, getSuccessMessage) {
+    const failedMessage = `⊙ ${toolName}: ${query} • failed`;
+    if (result.isError) {
+        const text = getToolResultText(result);
+        if (text.includes(E_CANCELLED)) {
+            return `⊙ ${toolName}: ${query} • cancelled`;
+        }
+        return failedMessage;
+    }
+    if (!isOkStructuredToolResult(result)) {
+        return failedMessage;
+    }
+    const payload = getToolResultPayload(result);
+    if (!payload) {
+        return `⊙ ${toolName}: ${query} • completed`;
+    }
+    const successSuffix = getSuccessMessage(payload);
+    return `⊙ ${toolName}: ${query} • ${successSuffix}`;
+}
+export function formatHashPreview(hash, length = 12) {
+    return `${hash.slice(0, length)}...`;
+}
+export function formatRelationshipPreview(fromHash, toHash, length = 8) {
+    return `${formatHashPreview(fromHash, length)} -> ${formatHashPreview(toHash, length)}`;
+}

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

@@ -1,4 +1,3 @@
 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.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,34 +46,17 @@ 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 failedMessage;
-    }
-    if (!isOkStructuredToolResult(result)) {
-        return failedMessage;
-    }
-    const payload = getToolResultPayload(result);
-    if (!payload) {
-        return `⊙ retrieve_context: ${query} • completed`;
-    }
-    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}`;
-}
-function throwIfAborted(signal) {
-    if (!signal?.aborted) {
-        return;
-    }
-    throw new Error(E_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);
@@ -103,9 +87,17 @@ function selectMemoriesWithinBudget(rows, candidateCount, tokenBudget, completio
     reportSelectionProgress(onProgress, scanned, completionCurrent, true);
     return { selected, estimatedTokens, truncated };
 }
+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 orderBy = ORDER_BY_MAP[params.strategy];
-    const rows = loadContextRows(db, params.query, orderBy, limit);
+    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;
@@ -115,7 +107,7 @@ function computeRetrieveContextResult(db, params, limit, signal, onProgress) {
     };
 }
 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}]`;
@@ -127,40 +119,16 @@ export function registerRetrieveContext(server, db) {
             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 { selection, completionCurrent: nextCompletionCurrent } = computeRetrieveContextResult(db, params, limit, extra.signal, loopProgress);
+            const computation = computeRetrieveContextResult(db, params, limit, extra.signal, loopProgress);
+            const { completionCurrent: nextCompletionCurrent } = computation;
             completionCurrent = nextCompletionCurrent;
-            result = createToolResponse({
-                memories: selection.selected,
-                estimated_tokens: selection.estimatedTokens,
-                truncated: selection.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),
+            return toRetrieveContextResponse(computation);
+        }, {
+            reporter: loopProgress,
+            completionCurrent: () => completionCurrent,
+            completionMessage: (result) => formatCompletionMessage(query, result),
         });
-        if (thrownError) {
-            throw thrownError;
-        }
-        return completionResult;
     });
 }

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

@@ -1,4 +1,3 @@
 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.js

@@ -4,12 +4,22 @@ import { loadRankedSearchRows, toMemoryFilters } from '../lib/search.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) => executeToolSafely(() => {
+    registerToolWithContract(server, 'search_memories', wrapToolHandler((params) => executeToolSafely(() => {
         const { limit, cursor } = params;
         const filters = toMemoryFilters(params);
         const scope = buildSearchCursorScope(params.query, filters);
@@ -19,14 +29,7 @@ export function registerSearchMemories(server, db) {
         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);
-            }
-        }
+        const nextCursor = buildNextCursorFromRows(scope, hasMore, pageRows);
         return createToolResponse({
             memories,
             total_returned: memories.length,

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

@@ -1,4 +1,3 @@
 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.js

@@ -3,8 +3,7 @@ import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { INSERT_MEMORY_SQL } from '../lib/sql.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 {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 async function notifyCreatedResources(server, items) {
@@ -14,7 +13,7 @@ async function notifyCreatedResources(server, items) {
     await Promise.allSettled(notifications);
 }
 export function registerStoreMemories(server, db) {
-    registerToolWithContract(server, 'store_memories', StoreMemoriesInputSchema, BatchResultSchema, wrapToolHandler(async (params) => executeToolSafely(async () => {
+    registerToolWithContract(server, 'store_memories', wrapToolHandler(async (params) => executeToolSafely(async () => {
         const now = new Date().toISOString();
         const results = db.transaction(() => {
             const items = [];

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

@@ -1,4 +1,3 @@
 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.js

@@ -3,8 +3,7 @@ import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { INSERT_MEMORY_SQL } from '../lib/sql.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 {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 function toInsertParams(params, hash, memoryType, now) {
@@ -25,7 +24,7 @@ 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) => executeToolSafely(async () => {
+    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();

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

@@ -1,4 +1,3 @@
 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