@j0hanz/memory-mcp 1.3.1 → 1.4.0

package/dist/schemas/inputs.js

@@ -70,6 +70,23 @@ const RECALL_MEMORY_TYPE_DESCRIPTION = 'Memory type filter';
 function describeImportanceFilter(description) {
     return IMPORTANCE_FILTER_SCHEMA.clone().describe(description);
 }
+function createSearchFilterFields(descriptions) {
+    return {
+        min_importance: describeImportanceFilter(descriptions.min),
+        max_importance: describeImportanceFilter(descriptions.max),
+        memory_type: MEMORY_TYPE_SCHEMA.optional().describe(descriptions.type),
+    };
+}
+const SEARCH_FILTER_FIELDS = createSearchFilterFields({
+    min: SEARCH_MIN_IMPORTANCE_DESCRIPTION,
+    max: SEARCH_MAX_IMPORTANCE_DESCRIPTION,
+    type: SEARCH_MEMORY_TYPE_DESCRIPTION,
+});
+const RECALL_FILTER_FIELDS = createSearchFilterFields({
+    min: RECALL_MIN_IMPORTANCE_DESCRIPTION,
+    max: RECALL_MAX_IMPORTANCE_DESCRIPTION,
+    type: RECALL_MEMORY_TYPE_DESCRIPTION,
+});
 const STORE_MEMORY_SHAPE = {
     content: CONTENT_SCHEMA,
     tags: TAGS_ARRAY_SCHEMA,
@@ -132,9 +149,7 @@ export const SearchMemoriesInputSchema = z
         .prefault(20)
         .describe('Max results (default 20)'),
     cursor: CURSOR_SCHEMA.optional().describe(CURSOR_DESCRIPTION),
-    min_importance: describeImportanceFilter(SEARCH_MIN_IMPORTANCE_DESCRIPTION),
-    max_importance: describeImportanceFilter(SEARCH_MAX_IMPORTANCE_DESCRIPTION),
-    memory_type: MEMORY_TYPE_SCHEMA.optional().describe(SEARCH_MEMORY_TYPE_DESCRIPTION),
+    ...SEARCH_FILTER_FIELDS,
 })
     .describe('Search memories');
 export const RecallInputSchema = z
@@ -155,9 +170,7 @@ export const RecallInputSchema = z
         .prefault(10)
         .describe('Max seed memories (default 10)'),
     cursor: CURSOR_SCHEMA.optional().describe(CURSOR_DESCRIPTION),
-    min_importance: describeImportanceFilter(RECALL_MIN_IMPORTANCE_DESCRIPTION),
-    max_importance: describeImportanceFilter(RECALL_MAX_IMPORTANCE_DESCRIPTION),
-    memory_type: MEMORY_TYPE_SCHEMA.optional().describe(RECALL_MEMORY_TYPE_DESCRIPTION),
+    ...RECALL_FILTER_FIELDS,
 })
     .describe('Recall memories via graph traversal');
 export const RetrieveContextInputSchema = z
@@ -204,4 +217,3 @@ export const DeleteRelationshipInputSchema = z
 export const MemoryStatsInputSchema = z
     .strictObject({})
     .describe('Get memory stats');
-//# sourceMappingURL=inputs.js.map

package/dist/schemas/outputs.d.ts

@@ -145,4 +145,3 @@ export declare const RetrieveContextResultSchema: z.ZodObject<{
     estimated_tokens: z.ZodNumber;
     truncated: z.ZodBoolean;
 }, z.core.$strict>;
-//# sourceMappingURL=outputs.d.ts.map

package/dist/schemas/outputs.js

@@ -2,6 +2,7 @@ import { z } from 'zod/v4';
 const STRING_SCHEMA = z.string();
 const NUMBER_SCHEMA = z.number();
 const BOOLEAN_SCHEMA = z.boolean();
+const STRING_ARRAY_SCHEMA = z.array(STRING_SCHEMA);
 export const ErrorResultSchema = z
     .strictObject({
     code: STRING_SCHEMA.describe('Error code'),
@@ -12,7 +13,7 @@ export const MemorySchema = z
     .strictObject({
     hash: STRING_SCHEMA.describe('SHA-256 hash'),
     content: STRING_SCHEMA.describe('Memory content'),
-    tags: z.array(STRING_SCHEMA).describe('Memory tags'),
+    tags: STRING_ARRAY_SCHEMA.describe('Memory tags'),
     memory_type: STRING_SCHEMA.describe('Memory type'),
     importance: NUMBER_SCHEMA.describe('Importance (0-10)'),
     created_at: STRING_SCHEMA.describe('Created at'),
@@ -77,7 +78,7 @@ export const RelationshipWithMemorySchema = z
     created_at: z.string().describe('Created at'),
     linked_hash: z.string().describe('Linked memory hash'),
     linked_content: z.string().describe('Linked memory content'),
-    linked_tags: z.array(z.string()).describe('Linked memory tags'),
+    linked_tags: STRING_ARRAY_SCHEMA.describe('Linked memory tags'),
 })
     .describe('Relationship edge with linked memory');
 export const RelationshipResultSchema = z
@@ -132,4 +133,3 @@ export const RetrieveContextResultSchema = z
     truncated: BOOLEAN_SCHEMA.describe('True if truncated by budget'),
 })
     .describe('Retrieve context result');
-//# sourceMappingURL=outputs.js.map

package/dist/server.d.ts

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

package/dist/server.js

@@ -14,14 +14,22 @@ const SERVER_NAME = 'memory-mcp';
 const SERVER_CAPABILITIES = {
     logging: {},
     completions: {},
-    resources: { subscribe: true },
+    resources: {},
     prompts: {},
     tools: {},
-    tasks: {
-        list: {},
-        cancel: {},
-    },
 };
+function getIconAssetCandidates() {
+    return [
+        new URL(`../assets/${ICON_ASSET}`, import.meta.url),
+        new URL(`./assets/${ICON_ASSET}`, import.meta.url),
+    ];
+}
+function isOversizedIcon(byteLength) {
+    return byteLength >= MAX_ICON_BYTES;
+}
+function toIconDataUri(bytes) {
+    return `data:${ICON_MIME};base64,${bytes.toString('base64')}`;
+}
 function parsePackageManifest(contents) {
     return JSON.parse(contents);
 }
@@ -33,19 +41,15 @@ function loadPackageManifest() {
     return parsePackageManifest(readFileSync(pkgPath, 'utf-8'));
 }
 function getLocalIconData() {
-    const candidates = [
-        new URL(`../assets/${ICON_ASSET}`, import.meta.url),
-        new URL(`./assets/${ICON_ASSET}`, import.meta.url),
-    ];
-    for (const candidate of candidates) {
+    for (const candidate of getIconAssetCandidates()) {
         try {
             const filePath = fileURLToPath(candidate);
             const buf = readFileSync(filePath);
-            if (buf.byteLength >= MAX_ICON_BYTES) {
+            if (isOversizedIcon(buf.byteLength)) {
                 console.warn(`Icon asset exceeds 2 MB (${buf.byteLength} bytes), skipping.`);
                 return undefined;
             }
-            return `data:${ICON_MIME};base64,${buf.toString('base64')}`;
+            return toIconDataUri(buf);
         }
         catch {
             // try next candidate
@@ -76,4 +80,3 @@ export function createServer(db) {
     registerAllPrompts(server);
     return server;
 }
-//# sourceMappingURL=server.js.map

package/dist/tools/create-relationship.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 registerCreateRelationship(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=create-relationship.d.ts.map

package/dist/tools/create-relationship.js

@@ -1,10 +1,10 @@
 import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
 import { logToolEvent } from '../lib/mcp-utils.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { CreateRelationshipInputSchema } from '../schemas/inputs.js';
+import { CreateRelationshipResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 const INSERT_RELATIONSHIP_SQL = `INSERT OR IGNORE INTO relationships (from_hash, to_hash, relation_type, created_at)
   VALUES (?, ?, ?, ?)`;
 const SELECT_HASHES_SQL = 'SELECT hash FROM memories WHERE hash IN (?, ?) LIMIT 2';
@@ -24,32 +24,37 @@ function getMissingEndpoint(db, params) {
     }
     return undefined;
 }
+function createRelationshipTx(db, params) {
+    return db.transaction(() => {
+        const missing = getMissingEndpoint(db, params);
+        if (missing) {
+            return {
+                ok: false,
+                code: E_NOT_FOUND,
+                message: formatMemoryNotFound(missing.kind, missing.hash),
+            };
+        }
+        const now = new Date().toISOString();
+        const result = db
+            .prepareOnce(INSERT_RELATIONSHIP_SQL)
+            .run(params.from_hash, params.to_hash, params.relation_type, now);
+        return { ok: true, created: result.changes > 0 };
+    });
+}
 export function registerCreateRelationship(server, db) {
-    const contract = getToolContract('create_relationship');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler(async (params) => {
+    registerToolWithContract(server, 'create_relationship', CreateRelationshipInputSchema, CreateRelationshipResultSchema, wrapToolHandler(async (params) => {
         try {
-            const missing = getMissingEndpoint(db, params);
-            if (missing) {
-                return createErrorResponse(E_NOT_FOUND, formatMemoryNotFound(missing.kind, missing.hash));
+            const txResult = createRelationshipTx(db, params);
+            if (!txResult.ok) {
+                return createErrorResponse(txResult.code, txResult.message);
             }
-            const now = new Date().toISOString();
-            const result = db
-                .prepareOnce(INSERT_RELATIONSHIP_SQL)
-                .run(params.from_hash, params.to_hash, params.relation_type, now);
-            const created = result.changes > 0;
             await logToolEvent(server, 'create_relationship', {
                 fromHash: params.from_hash,
                 toHash: params.to_hash,
                 relationType: params.relation_type,
-                created,
+                created: txResult.created,
             });
-            return createToolResponse({ created });
+            return createToolResponse({ created: txResult.created });
         }
         catch (err) {
             rethrowMcpError(err);
@@ -59,4 +64,3 @@ export function registerCreateRelationship(server, db) {
         progressMessage: (params) => `⊕ create_relationship: ${params.from_hash.slice(0, 8)}... -> ${params.to_hash.slice(0, 8)}... [${params.relation_type}]`,
     }));
 }
-//# sourceMappingURL=create-relationship.js.map

package/dist/tools/delete-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 registerDeleteMemories(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=delete-memories.d.ts.map

package/dist/tools/delete-memories.js

@@ -1,11 +1,11 @@
 import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { DELETE_MEMORY_SQL } from '../lib/sql.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { DeleteMemoriesInputSchema } from '../schemas/inputs.js';
+import { BatchResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 async function notifyDeletedResources(server, items) {
     const notifications = items
         .filter((item) => item.deleted)
@@ -13,14 +13,7 @@ async function notifyDeletedResources(server, items) {
     await Promise.allSettled(notifications);
 }
 export function registerDeleteMemories(server, db) {
-    const contract = getToolContract('delete_memories');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler(async (params) => {
+    registerToolWithContract(server, 'delete_memories', DeleteMemoriesInputSchema, BatchResultSchema, wrapToolHandler(async (params) => {
         try {
             const results = db.transaction(() => {
                 const items = [];
@@ -59,4 +52,3 @@ export function registerDeleteMemories(server, db) {
         progressMessage: (params) => `⊖ delete_memories: ${params.hashes.length} hashes [batch]`,
     }));
 }
-//# sourceMappingURL=delete-memories.js.map

package/dist/tools/delete-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 registerDeleteMemory(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=delete-memory.d.ts.map

package/dist/tools/delete-memory.js

@@ -1,23 +1,16 @@
 import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { DELETE_MEMORY_SQL } from '../lib/sql.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { DeleteMemoryInputSchema } from '../schemas/inputs.js';
+import { DeleteResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 function deleteByHash(db, hash) {
     return db.prepareOnce(DELETE_MEMORY_SQL).run(hash).changes > 0;
 }
 export function registerDeleteMemory(server, db) {
-    const contract = getToolContract('delete_memory');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler(async (params) => {
+    registerToolWithContract(server, 'delete_memory', DeleteMemoryInputSchema, DeleteResultSchema, wrapToolHandler(async (params) => {
         try {
             const deleted = deleteByHash(db, params.hash);
             if (deleted) {
@@ -34,4 +27,3 @@ export function registerDeleteMemory(server, db) {
         progressMessage: (params) => `⊖ delete_memory: ${params.hash.slice(0, 12)}... [single]`,
     }));
 }
-//# sourceMappingURL=delete-memory.js.map

package/dist/tools/delete-relationship.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 registerDeleteRelationship(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=delete-relationship.d.ts.map

package/dist/tools/delete-relationship.js

@@ -1,9 +1,9 @@
 import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { DeleteRelationshipInputSchema } from '../schemas/inputs.js';
+import { DeleteRelationshipResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 const DELETE_RELATIONSHIP_SQL = 'DELETE FROM relationships WHERE from_hash = ? AND to_hash = ? AND relation_type = ?';
 const DELETE_RELATIONSHIP_RESULT = { deleted: true };
 function formatRelationship(params) {
@@ -18,14 +18,7 @@ function deleteRelationship(db, params) {
         .run(params.from_hash, params.to_hash, params.relation_type).changes > 0);
 }
 export function registerDeleteRelationship(server, db) {
-    const contract = getToolContract('delete_relationship');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler((params) => {
+    registerToolWithContract(server, 'delete_relationship', DeleteRelationshipInputSchema, DeleteRelationshipResultSchema, wrapToolHandler((params) => {
         try {
             if (!deleteRelationship(db, params)) {
                 return createErrorResponse(E_NOT_FOUND, createNotFoundRelationshipMessage(params));
@@ -40,4 +33,3 @@ export function registerDeleteRelationship(server, db) {
         progressMessage: (params) => `⊖ delete_relationship: ${params.from_hash.slice(0, 8)}... -> ${params.to_hash.slice(0, 8)}... [${params.relation_type}]`,
     }));
 }
-//# sourceMappingURL=delete-relationship.js.map

package/dist/tools/get-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 registerGetMemory(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=get-memory.d.ts.map

package/dist/tools/get-memory.js

@@ -1,11 +1,11 @@
 import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
 import { SELECT_MEMORY_BY_HASH_SQL } from '../lib/sql.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
 import { parseMemoryRow } from '../lib/types.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { GetMemoryInputSchema } from '../schemas/inputs.js';
+import { MemoryResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 function getMemoryRow(db, hash) {
     return db.prepareOnce(SELECT_MEMORY_BY_HASH_SQL).get(hash);
 }
@@ -13,14 +13,7 @@ function notFound(hash) {
     return createErrorResponse(E_NOT_FOUND, `Memory not found: ${hash}`);
 }
 export function registerGetMemory(server, db) {
-    const contract = getToolContract('get_memory');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler((params) => {
+    registerToolWithContract(server, 'get_memory', GetMemoryInputSchema, MemoryResultSchema, wrapToolHandler((params) => {
         try {
             const row = getMemoryRow(db, params.hash);
             if (!row) {
@@ -37,4 +30,3 @@ export function registerGetMemory(server, db) {
         progressMessage: (params) => `⊙ get_memory: ${params.hash.slice(0, 12)}... [single]`,
     }));
 }
-//# sourceMappingURL=get-memory.js.map

package/dist/tools/get-relationships.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 registerGetRelationships(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=get-relationships.d.ts.map

package/dist/tools/get-relationships.js

@@ -1,11 +1,11 @@
 import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
 import { SELECT_MEMORY_HASH_SQL } from '../lib/sql.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
 import { parseTags } from '../lib/types.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { GetRelationshipsInputSchema } from '../schemas/inputs.js';
+import { RelationshipResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 // Pre-defined SQL for each direction mode to maximise prepareOnce cache hits.
 const OUTGOING_SQL = `
   SELECT r.from_hash, r.to_hash, r.relation_type, r.created_at,
@@ -22,6 +22,7 @@ const INCOMING_SQL = `
   WHERE r.to_hash = ?
   ORDER BY r.created_at DESC`;
 // UNION ALL for 'both': single round-trip instead of two separate queries.
+// Exclude self-loops from the second branch to avoid duplicate rows.
 const BOTH_SQL = `
   SELECT r.from_hash, r.to_hash, r.relation_type, r.created_at,
          m.hash AS linked_hash, m.content AS linked_content, m.tags AS linked_tags
@@ -34,6 +35,7 @@ const BOTH_SQL = `
   FROM relationships r
   JOIN memories m ON r.from_hash = m.hash
   WHERE r.to_hash = ?
+    AND r.from_hash != ?
   ORDER BY 4 DESC`;
 function memoryExists(db, hash) {
     return (db.prepareOnce(SELECT_MEMORY_HASH_SQL).get(hash) !==
@@ -41,7 +43,7 @@ function memoryExists(db, hash) {
 }
 function loadRelationships(db, hash, direction) {
     if (direction === 'both') {
-        return db.prepareOnce(BOTH_SQL).all(hash, hash);
+        return db.prepareOnce(BOTH_SQL).all(hash, hash, hash);
     }
     const sql = direction === 'outgoing' ? OUTGOING_SQL : INCOMING_SQL;
     return db.prepareOnce(sql).all(hash);
@@ -58,14 +60,7 @@ function toRelationshipWithMemory(row) {
     };
 }
 export function registerGetRelationships(server, db) {
-    const contract = getToolContract('get_relationships');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler((params) => {
+    registerToolWithContract(server, 'get_relationships', GetRelationshipsInputSchema, RelationshipResultSchema, wrapToolHandler((params) => {
         try {
             if (!memoryExists(db, params.hash)) {
                 return createErrorResponse(E_NOT_FOUND, `Memory not found: ${params.hash}`);
@@ -85,4 +80,3 @@ export function registerGetRelationships(server, db) {
         progressMessage: (params) => `⊙ get_relationships: ${params.hash.slice(0, 12)}... [${params.direction}]`,
     }));
 }
-//# sourceMappingURL=get-relationships.js.map

package/dist/tools/index.d.ts

@@ -4,4 +4,3 @@ type ToolRegistrar = (server: McpServer, db: TypedDb) => void;
 export declare const TOOL_REGISTRARS: readonly ToolRegistrar[];
 export declare function registerAllTools(server: McpServer, db: TypedDb): void;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -27,8 +27,7 @@ export const TOOL_REGISTRARS = [
     registerRetrieveContext,
 ];
 export function registerAllTools(server, db) {
-    for (const registerTool of TOOL_REGISTRARS) {
-        registerTool(server, db);
+    for (const register of TOOL_REGISTRARS) {
+        register(server, db);
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/tools/memory-stats.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 registerMemoryStats(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=memory-stats.d.ts.map

package/dist/tools/memory-stats.js

@@ -1,10 +1,10 @@
 import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { MEMORY_AGGREGATE_SQL, RELATIONSHIP_COUNT_SQL, TYPE_COUNTS_SQL, } from '../lib/sql.js';
-import { getToolContract } from '../lib/tool-contracts.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import {} from '../schemas/inputs.js';
-import {} from '../schemas/outputs.js';
+import { MemoryStatsInputSchema } from '../schemas/inputs.js';
+import { StatsResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
+import { registerToolWithContract } from './register-contract.js';
 function toTypeCounts(rows) {
     const byType = {};
     for (const row of rows) {
@@ -13,14 +13,7 @@ function toTypeCounts(rows) {
     return byType;
 }
 export function registerMemoryStats(server, db) {
-    const contract = getToolContract('memory_stats');
-    server.registerTool(contract.name, {
-        title: contract.title,
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, wrapToolHandler(() => {
+    registerToolWithContract(server, 'memory_stats', MemoryStatsInputSchema, StatsResultSchema, wrapToolHandler(() => {
         try {
             const aggregate = db
                 .prepareOnce(MEMORY_AGGREGATE_SQL)
@@ -47,4 +40,3 @@ export function registerMemoryStats(server, db) {
         }
     }, { progressMessage: () => '⊙ memory_stats: [aggregate]' }));
 }
-//# sourceMappingURL=memory-stats.js.map

package/dist/tools/progress.d.ts

@@ -2,8 +2,9 @@ import type { CallToolResult, ProgressNotification } from '@modelcontextprotocol
 interface ProgressMeta {
     progressToken?: unknown;
 }
-interface ProgressContext {
+export interface ProgressContext {
     _meta?: ProgressMeta;
+    signal?: AbortSignal;
     sendNotification?: (notification: ProgressNotification) => Promise<void>;
 }
 interface ProgressUpdate {
@@ -31,4 +32,3 @@ export declare function createProgressReporter(extra: ProgressContext, options?:
 export declare function progressWithMessage(reporter: ProgressReporter, getMessage: (progress: ProgressSnapshot) => string): ProgressReporter<ProgressSnapshot>;
 export declare function wrapToolHandler<TArgs>(handler: ToolHandler<TArgs>, options: WrappedHandlerOptions<TArgs>): ToolHandler<TArgs>;
 export {};
-//# sourceMappingURL=progress.d.ts.map

package/dist/tools/progress.js

@@ -1,4 +1,5 @@
 import { E_CANCELLED } from '../lib/errors.js';
+import { getToolResultText } from './result.js';
 const DEFAULT_PROGRESS_INTERVAL_MS = 250;
 function toProgressToken(value) {
     if (typeof value === 'string' || typeof value === 'number') {
@@ -21,7 +22,7 @@ function toNotificationParams(progressToken, progress) {
 }
 function getResultOutcome(result) {
     if (result.isError) {
-        const text = result.content[0]?.type === 'text' ? result.content[0].text : '';
+        const text = getToolResultText(result);
         if (text.includes(E_CANCELLED)) {
             return 'cancelled';
         }
@@ -131,4 +132,3 @@ export function wrapToolHandler(handler, options) {
         return result;
     };
 }
-//# sourceMappingURL=progress.js.map

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