@j0hanz/memory-mcp 1.5.0 → 1.6.0

package/dist/resources/index.js

@@ -44,6 +44,13 @@ function createResourceAnnotations(audience, priority) {
 function getSingleVariable(value) {
     return Array.isArray(value) ? value[0] : value;
 }
+function requireValidMemoryHash(variables) {
+    const hash = getSingleVariable(variables['hash']);
+    if (!hash || !HASH_REGEX.test(hash)) {
+        throw new McpError(ErrorCode.InvalidParams, 'Invalid hash: must be a 64-character hex string');
+    }
+    return hash;
+}
 function requireSingleVariable(variables, key, errorMessage) {
     const value = getSingleVariable(variables[key]);
     if (!value) {
@@ -51,6 +58,13 @@ function requireSingleVariable(variables, key, errorMessage) {
     }
     return value;
 }
+function requireKnownToolInfo(toolName) {
+    const info = getToolInfo(toolName);
+    if (!info) {
+        throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${toolName}`);
+    }
+    return info;
+}
 function registerStaticMarkdownResource(server, config) {
     server.registerResource(config.name, config.uri, {
         title: config.title,
@@ -90,28 +104,67 @@ const INSTRUCTIONS_CONTENT = loadInstructions();
 const TOOL_CATALOG_CONTENT = buildToolCatalog();
 const WORKFLOW_GUIDE_CONTENT = buildWorkflowGuide();
 const SERVER_CONFIG_CONTENT = buildServerConfig();
-// --- Registration ---
-export function registerAllResources(server, db) {
-    // internal://instructions
-    registerStaticMarkdownResource(server, {
+const STATIC_RESOURCE_SEEDS = [
+    {
         name: 'instructions',
         uri: INSTRUCTIONS_URI,
         title: 'Memory Instructions',
         description: 'Complete usage guide: tool inventory, routing decisions, error codes, data model, and workflow patterns. Read this first.',
         audience: ['assistant'],
         priority: 0.9,
-        content: INSTRUCTIONS_CONTENT,
-    });
-    // internal://tool-catalog
-    registerStaticMarkdownResource(server, {
+        contentKey: 'instructions',
+    },
+    {
         name: 'tool-catalog',
         uri: TOOL_CATALOG_URI,
         title: 'Tool Catalog',
         description: 'Tool reference table, optional parameter matrix, and cross-tool data flow.',
         audience: ['assistant'],
         priority: 0.7,
-        content: TOOL_CATALOG_CONTENT,
-    });
+        contentKey: 'toolCatalog',
+    },
+    {
+        name: 'workflows',
+        uri: WORKFLOWS_URI,
+        title: 'Workflow Guide',
+        description: 'Recommended multi-step workflow sequences with guardrails and tool reference.',
+        audience: ['assistant'],
+        priority: 0.7,
+        contentKey: 'workflows',
+    },
+    {
+        name: 'server-config',
+        uri: SERVER_CONFIG_URI,
+        title: 'Server Configuration',
+        description: 'Runtime configuration, environment variables, capabilities, and data limits.',
+        audience: ['user', 'assistant'],
+        priority: 0.5,
+        contentKey: 'serverConfig',
+    },
+];
+function resolveStaticResourceContent(contentKey) {
+    switch (contentKey) {
+        case 'instructions':
+            return INSTRUCTIONS_CONTENT;
+        case 'toolCatalog':
+            return TOOL_CATALOG_CONTENT;
+        case 'workflows':
+            return WORKFLOW_GUIDE_CONTENT;
+        case 'serverConfig':
+            return SERVER_CONFIG_CONTENT;
+    }
+}
+function getStaticMarkdownResources() {
+    return STATIC_RESOURCE_SEEDS.map((seed) => ({
+        ...seed,
+        content: resolveStaticResourceContent(seed.contentKey),
+    }));
+}
+// --- Registration ---
+export function registerAllResources(server, db) {
+    for (const config of getStaticMarkdownResources()) {
+        registerStaticMarkdownResource(server, config);
+    }
     // internal://tool-info/{toolName}
     server.registerResource('tool-info', new ResourceTemplate(TOOL_INFO_URI_TEMPLATE, {
         list: () => listToolInfoResources(),
@@ -125,34 +178,11 @@ export function registerAllResources(server, db) {
         annotations: createResourceAnnotations(['assistant'], 0.6),
     }, (uri, variables) => {
         const toolName = requireSingleVariable(variables, 'toolName', 'Missing toolName parameter');
-        const info = getToolInfo(toolName);
-        if (!info) {
-            throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${toolName}`);
-        }
+        const info = requireKnownToolInfo(toolName);
         return {
             contents: [createMarkdownContent(uri.href, info)],
         };
     });
-    // internal://workflows
-    registerStaticMarkdownResource(server, {
-        name: 'workflows',
-        uri: WORKFLOWS_URI,
-        title: 'Workflow Guide',
-        description: 'Recommended multi-step workflow sequences with guardrails and tool reference.',
-        audience: ['assistant'],
-        priority: 0.7,
-        content: WORKFLOW_GUIDE_CONTENT,
-    });
-    // internal://server-config
-    registerStaticMarkdownResource(server, {
-        name: 'server-config',
-        uri: SERVER_CONFIG_URI,
-        title: 'Server Configuration',
-        description: 'Runtime configuration, environment variables, capabilities, and data limits.',
-        audience: ['user', 'assistant'],
-        priority: 0.5,
-        content: SERVER_CONFIG_CONTENT,
-    });
     // memory://memories/{hash}
     const hashCompletion = createHashCompletionCallback(db);
     server.registerResource('memory', new ResourceTemplate(MEMORY_RESOURCE_URI_TEMPLATE, {
@@ -164,10 +194,7 @@ export function registerAllResources(server, db) {
         mimeType: 'application/json',
         annotations: createResourceAnnotations(['assistant'], 0.7),
     }, (uri, variables) => {
-        const hash = getSingleVariable(variables['hash']);
-        if (!hash || !HASH_REGEX.test(hash)) {
-            throw new McpError(ErrorCode.InvalidParams, 'Invalid hash: must be a 64-character hex string');
-        }
+        const hash = requireValidMemoryHash(variables);
         const row = readMemoryByHash(db, hash);
         if (!row) {
             return createErrorResourceContents(uri.href, 'Not found', hash);

package/dist/resources/instructions.d.ts

@@ -1 +1,2 @@
 export declare function buildServerInstructions(): string;
+//# sourceMappingURL=instructions.d.ts.map

package/dist/resources/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../src/resources/instructions.ts"],"names":[],"mappings":"AA8HA,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/resources/instructions.js

@@ -63,42 +63,49 @@ function renderSharedConstraints() {
         .map((c) => `- ${c}`)
         .join('\n');
 }
-export function buildServerInstructions() {
+function renderTaggedSection(section) {
+    return [`<${section.tag}>`, section.content, `</${section.tag}>`].join('\n');
+}
+function buildTaggedSections() {
     return [
-        '<role>',
-        'Memory MCP: Persistent memory storage, full-text retrieval, and relationship graph traversal.',
-        '</role>',
-        '',
-        '<capabilities>',
-        buildToolRouting(),
-        '</capabilities>',
-        '',
-        '<constraints>',
-        renderSharedConstraints(),
-        '</constraints>',
-        '',
-        '<error_codes>',
-        ERROR_CODES.join('\n'),
-        '</error_codes>',
-        '',
-        '<error_result_conventions>',
-        ERROR_RESULT_CONVENTIONS.join('\n'),
-        '</error_result_conventions>',
-        '',
-        '<data_model>',
-        DATA_MODEL,
-        '</data_model>',
-        '',
-        '<workflows>',
-        WORKFLOWS,
-        '</workflows>',
-        '',
-        '<prompts>',
-        PROMPTS_INVENTORY.join('\n'),
-        '</prompts>',
-        '',
-        '<resources>',
-        RESOURCES_INVENTORY.join('\n'),
-        '</resources>',
-    ].join('\n');
+        {
+            tag: 'role',
+            content: 'Memory MCP: Persistent memory storage, full-text retrieval, and relationship graph traversal.',
+        },
+        {
+            tag: 'capabilities',
+            content: buildToolRouting(),
+        },
+        {
+            tag: 'constraints',
+            content: renderSharedConstraints(),
+        },
+        {
+            tag: 'error_codes',
+            content: ERROR_CODES.join('\n'),
+        },
+        {
+            tag: 'error_result_conventions',
+            content: ERROR_RESULT_CONVENTIONS.join('\n'),
+        },
+        {
+            tag: 'data_model',
+            content: DATA_MODEL,
+        },
+        {
+            tag: 'workflows',
+            content: WORKFLOWS,
+        },
+        {
+            tag: 'prompts',
+            content: PROMPTS_INVENTORY.join('\n'),
+        },
+        {
+            tag: 'resources',
+            content: RESOURCES_INVENTORY.join('\n'),
+        },
+    ];
+}
+export function buildServerInstructions() {
+    return buildTaggedSections().map(renderTaggedSection).join('\n\n');
 }

package/dist/resources/server-config.d.ts

@@ -1 +1,2 @@
 export declare function buildServerConfig(): string;
+//# sourceMappingURL=server-config.d.ts.map

package/dist/resources/server-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-config.d.ts","sourceRoot":"","sources":["../../src/resources/server-config.ts"],"names":[],"mappings":"AA0EA,wBAAgB,iBAAiB,IAAI,MAAM,CA2B1C"}

package/dist/resources/server-config.js

@@ -46,32 +46,43 @@ const CAPABILITIES = [
 function toEnvVarRow(v) {
     return `| \`${v.name}\` | ${v.default} | ${v.range} | ${v.purpose} |`;
 }
-function toRangeRow(label, range) {
-    return `| ${label} | ${range} |`;
+function toTwoColumnRow(label, value) {
+    return `| ${label} | ${value} |`;
 }
-export function buildServerConfig() {
-    const envRows = ENV_VARS.map(toEnvVarRow);
-    const limitRows = DATA_LIMITS.map((l) => toRangeRow(l.dimension, l.range));
-    const capRows = CAPABILITIES.map((c) => toRangeRow(c.capability, c.status));
+function renderTableSection(section) {
     return [
-        '# Server Configuration',
-        '',
-        '## Environment Variables',
-        '',
-        '| Variable | Default | Range | Purpose |',
-        '|----------|---------|-------|---------|',
-        ...envRows,
-        '',
-        '## Capabilities',
+        `## ${section.title}`,
         '',
-        '| Capability | Status |',
-        '|------------|--------|',
-        ...capRows,
+        section.header,
+        section.separator,
+        ...section.rows,
         '',
-        '## Data Limits',
+    ];
+}
+export function buildServerConfig() {
+    const sections = [
+        {
+            title: 'Environment Variables',
+            header: '| Variable | Default | Range | Purpose |',
+            separator: '|----------|---------|-------|---------|',
+            rows: ENV_VARS.map(toEnvVarRow),
+        },
+        {
+            title: 'Capabilities',
+            header: '| Capability | Status |',
+            separator: '|------------|--------|',
+            rows: CAPABILITIES.map((c) => toTwoColumnRow(c.capability, c.status)),
+        },
+        {
+            title: 'Data Limits',
+            header: '| Dimension | Range |',
+            separator: '|-----------|-------|',
+            rows: DATA_LIMITS.map((l) => toTwoColumnRow(l.dimension, l.range)),
+        },
+    ];
+    return [
+        '# Server Configuration',
         '',
-        '| Dimension | Range |',
-        '|-----------|-------|',
-        ...limitRows,
+        ...sections.flatMap(renderTableSection),
     ].join('\n');
 }

package/dist/resources/tool-catalog.d.ts

@@ -1 +1,2 @@
 export declare function buildToolCatalog(): string;
+//# sourceMappingURL=tool-catalog.d.ts.map

package/dist/resources/tool-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-catalog.d.ts","sourceRoot":"","sources":["../../src/resources/tool-catalog.ts"],"names":[],"mappings":"AA2DA,wBAAgB,gBAAgB,IAAI,MAAM,CA0BzC"}

package/dist/resources/tool-catalog.js

@@ -1,12 +1,17 @@
 import { extractJsonSchema, } from '../lib/json-schema.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 import { buildCoreContextPack } from './tool-info.js';
-function extractOptionalParams(toolName, schema) {
+function getSchemaMeta(schema) {
     const jsonSchema = extractJsonSchema(schema);
-    const properties = (jsonSchema['properties'] ?? {});
-    const requiredFields = new Set(Array.isArray(jsonSchema['required'])
-        ? jsonSchema['required']
-        : []);
+    return {
+        properties: (jsonSchema['properties'] ?? {}),
+        requiredFields: new Set(Array.isArray(jsonSchema['required'])
+            ? jsonSchema['required']
+            : []),
+    };
+}
+function extractOptionalParams(toolName, schema) {
+    const { properties, requiredFields } = getSchemaMeta(schema);
     const rows = [];
     for (const [name, prop] of Object.entries(properties).sort(([a], [b]) => a.localeCompare(b))) {
         if (requiredFields.has(name))

package/dist/resources/tool-info.d.ts

@@ -2,3 +2,4 @@ export declare function getSharedConstraints(): readonly string[];
 export declare function buildCoreContextPack(): string;
 export declare function getToolInfo(name: string): string | undefined;
 export declare function getToolNames(): string[];
+//# sourceMappingURL=tool-info.d.ts.map

package/dist/resources/tool-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-info.d.ts","sourceRoot":"","sources":["../../src/resources/tool-info.ts"],"names":[],"mappings":"AAkBA,wBAAgB,oBAAoB,IAAI,SAAS,MAAM,EAAE,CAExD;AA+BD,wBAAgB,oBAAoB,IAAI,MAAM,CAgB7C;AAqFD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoB5D;AAED,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAIvC"}

package/dist/resources/tool-info.js

@@ -61,6 +61,21 @@ function formatParamConstraints(prop) {
         parts.push(`enum: ${prop['enum'].join(' | ')}`);
     return parts.length > 0 ? `; ${parts.join(', ')}` : '';
 }
+function getSchemaMeta(schema) {
+    const jsonSchema = extractJsonSchema(schema);
+    return {
+        properties: (jsonSchema['properties'] ?? {}),
+        requiredFields: new Set(Array.isArray(jsonSchema['required'])
+            ? jsonSchema['required']
+            : []),
+    };
+}
+function getSortedSchemaProperties(properties) {
+    return Object.entries(properties).sort(([a], [b]) => a.localeCompare(b));
+}
+function formatParamLines(meta) {
+    return getSortedSchemaProperties(meta.properties).map(([pName, pSchema]) => formatParam(pName, pSchema, meta.requiredFields.has(pName)));
+}
 function formatParam(name, prop, required) {
     const type = typeof prop['type'] === 'string' ? prop['type'] : 'unknown';
     const desc = typeof prop['description'] === 'string' ? prop['description'] : '';
@@ -87,14 +102,8 @@ export function getToolInfo(name) {
     const contract = getToolContracts().find((c) => c.name === name);
     if (!contract)
         return undefined;
-    const inputSchema = extractJsonSchema(contract.inputSchema);
-    const properties = (inputSchema['properties'] ?? {});
-    const requiredFields = new Set(Array.isArray(inputSchema['required'])
-        ? inputSchema['required']
-        : []);
-    const paramLines = Object.entries(properties)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([pName, pSchema]) => formatParam(pName, pSchema, requiredFields.has(pName)));
+    const inputMeta = getSchemaMeta(contract.inputSchema);
+    const paramLines = formatParamLines(inputMeta);
     const behaviorLine = formatBehavior(contract.annotations);
     const outputShape = formatOutputShape(contract.outputSchema);
     return [

package/dist/resources/workflows.d.ts

@@ -1 +1,2 @@
 export declare function buildWorkflowGuide(): string;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/resources/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/resources/workflows.ts"],"names":[],"mappings":"AAqFA,wBAAgB,kBAAkB,IAAI,MAAM,CAW3C"}

package/dist/resources/workflows.js

@@ -1,53 +1,82 @@
 import { getSharedConstraints } from './tool-info.js';
-const WORKFLOW_TRACKS = `## Workflow A: Store and Link
-
-1. \`store_memories({ items: [...] })\` → \`{ items[].hash, succeeded, failed }\`
-2. \`create_relationship({ from_hash, to_hash, relation_type })\` × N
-
-> Constraint: Both endpoint memories must exist before creating a relationship.
-
-## Workflow B: Search and Read
-
-1. \`search_memories({ query, limit })\` → \`{ memories[], nextCursor }\`
-2. \`get_memory({ hash })\` for full detail on a specific result
-
-> Or use \`recall({ query, depth: 1 })\` → \`{ memories[], graph[] }\` to follow relationships.
-
-## Workflow C: Fill Context Window
-
-1. \`retrieve_context({ query, token_budget: 4000, strategy: 'relevance' })\` → \`{ memories[], estimated_tokens, truncated }\`
-
-> Use \`strategy\` to control sort: \`relevance\` (FTS rank), \`importance\` (highest first), or \`recency\` (newest first).
-
-## Workflow D: Update a Memory
-
-1. \`update_memory({ hash, content })\` → \`{ old_hash, new_hash }\`
-
-> Existing relationships auto-update to new_hash via CASCADE.
-> Returns E_CONFLICT if the new content+tags already maps to an existing hash.
-
-## Workflow E: Batch Delete
-
-1. \`delete_memories({ hashes: [...] })\` → \`{ items[].{ hash, deleted }, succeeded, failed }\`
-
-> \`deleted: false\` means hash not found — not an error, the batch still succeeds.
-
-## Workflow F: Explore Graph
-
-1. \`recall({ query, depth: 2 })\` → \`{ memories[], graph[], depth_reached, aborted }\`
-2. \`get_relationships({ hash, direction: 'both' })\` for a specific memory's edges
-
-> BFS traversal emits progress per hop. Use \`depth: 0\` to skip traversal.`;
+const WORKFLOW_TRACKS = [
+    {
+        title: 'Workflow A: Store and Link',
+        steps: [
+            '`store_memories({ items: [...] })` → `{ items[].hash, succeeded, failed }`',
+            '`create_relationship({ from_hash, to_hash, relation_type })` × N',
+        ],
+        notes: [
+            'Constraint: Both endpoint memories must exist before creating a relationship.',
+        ],
+    },
+    {
+        title: 'Workflow B: Search and Read',
+        steps: [
+            '`search_memories({ query, limit })` → `{ memories[], nextCursor }`',
+            '`get_memory({ hash })` for full detail on a specific result',
+        ],
+        notes: [
+            'Or use `recall({ query, depth: 1 })` → `{ memories[], graph[] }` to follow relationships.',
+        ],
+    },
+    {
+        title: 'Workflow C: Fill Context Window',
+        steps: [
+            "`retrieve_context({ query, token_budget: 4000, strategy: 'relevance' })` → `{ memories[], estimated_tokens, truncated }`",
+        ],
+        notes: [
+            'Use `strategy` to control sort: `relevance` (FTS rank), `importance` (highest first), or `recency` (newest first).',
+        ],
+    },
+    {
+        title: 'Workflow D: Update a Memory',
+        steps: ['`update_memory({ hash, content })` → `{ old_hash, new_hash }`'],
+        notes: [
+            'Existing relationships auto-update to new_hash via CASCADE.',
+            'Returns E_CONFLICT if the new content+tags already maps to an existing hash.',
+        ],
+    },
+    {
+        title: 'Workflow E: Batch Delete',
+        steps: [
+            '`delete_memories({ hashes: [...] })` → `{ items[].{ hash, deleted }, succeeded, failed }`',
+        ],
+        notes: [
+            '`deleted: false` means hash not found - not an error, the batch still succeeds.',
+        ],
+    },
+    {
+        title: 'Workflow F: Explore Graph',
+        steps: [
+            '`recall({ query, depth: 2 })` → `{ memories[], graph[], depth_reached, aborted }`',
+            "`get_relationships({ hash, direction: 'both' })` for a specific memory's edges",
+        ],
+        notes: [
+            'BFS traversal emits progress per hop. Use `depth: 0` to skip traversal.',
+        ],
+    },
+];
 function renderSharedConstraintsSection() {
     return getSharedConstraints()
         .map((c) => `- ${c}`)
         .join('\n');
 }
+function renderWorkflowTrack(track) {
+    const stepLines = track.steps
+        .map((step, idx) => `${idx + 1}. ${step}`)
+        .join('\n');
+    const noteLines = track.notes.map((note) => `> ${note}`).join('\n');
+    return [`## ${track.title}`, '', stepLines, '', noteLines].join('\n');
+}
+function renderWorkflowTracks() {
+    return WORKFLOW_TRACKS.map(renderWorkflowTrack).join('\n\n');
+}
 export function buildWorkflowGuide() {
     return [
         '# Workflow Reference',
         '',
-        WORKFLOW_TRACKS,
+        renderWorkflowTracks(),
         '',
         '## Shared Constraints',
         renderSharedConstraintsSection(),

package/dist/schemas/index.d.ts

@@ -1,2 +1,3 @@
 export * from './inputs.js';
 export * from './outputs.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dist/schemas/inputs.d.ts

@@ -118,3 +118,4 @@ export declare const DeleteRelationshipInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const MemoryStatsInputSchema: z.ZodObject<{}, z.core.$strict>;
 export {};
+//# sourceMappingURL=inputs.d.ts.map

package/dist/schemas/inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../src/schemas/inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,eAAO,MAAM,WAAW,aAMG,CAAC;AAe5B,QAAA,MAAM,kBAAkB;;;;;;;;;EAWM,CAAC;AAiB/B,eAAO,MAAM,wBAAwB,iIAU3B,CAAC;AAgEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;kBAID,CAAC;AAEnC,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;kBAIP,CAAC;AAEjC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;kBAQC,CAAC;AAEvC,eAAO,MAAM,oBAAoB;;kBAIA,CAAC;AAElC,eAAO,MAAM,uBAAuB;;;;kBAMR,CAAC;AAE7B,eAAO,MAAM,uBAAuB;;kBAIA,CAAC;AAErC,eAAO,MAAM,yBAAyB;;kBAQC,CAAC;AAQxC,eAAO,MAAM,yBAAyB;oBAvFpB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;oBAC1B,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;iBAC7B,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC;;;;kBAkGzB,CAAC;AAE/B,eAAO,MAAM,iBAAiB;oBAtGZ,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;oBAC1B,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;iBAC7B,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC;;;;;kBAwHL,CAAC;AAEnD,eAAO,MAAM,0BAA0B;;;;;;;;kBAgBY,CAAC;AAEpD,eAAO,MAAM,2BAA2B;;;;;;;kBASR,CAAC;AAEjC,eAAO,MAAM,6BAA6B;;;;kBAIR,CAAC;AAEnC,eAAO,MAAM,6BAA6B;;;;kBAIR,CAAC;AAEnC,eAAO,MAAM,sBAAsB,iCAEJ,CAAC"}

package/dist/schemas/inputs.js

@@ -67,6 +67,9 @@ const SEARCH_MEMORY_TYPE_DESCRIPTION = 'Memory type filter';
 const RECALL_MIN_IMPORTANCE_DESCRIPTION = 'Min importance filter';
 const RECALL_MAX_IMPORTANCE_DESCRIPTION = 'Max importance filter';
 const RECALL_MEMORY_TYPE_DESCRIPTION = 'Memory type filter';
+function describeHash(label) {
+    return HASH_SCHEMA.describe(label);
+}
 function describeImportanceFilter(description) {
     return IMPORTANCE_FILTER_SCHEMA.clone().describe(description);
 }
@@ -114,19 +117,19 @@ export const StoreMemoriesInputSchema = z
     .describe('Store multiple memories');
 export const GetMemoryInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
 })
     .describe('Get memory by hash');
 export const UpdateMemoryInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
     content: CONTENT_SCHEMA,
     tags: TAGS_ARRAY_SCHEMA.optional(),
 })
     .describe('Update memory');
 export const DeleteMemoryInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
 })
     .describe('Delete memory by hash');
 export const DeleteMemoriesInputSchema = z
@@ -138,6 +141,11 @@ export const DeleteMemoriesInputSchema = z
         .describe('Hashes to delete (1-50)'),
 })
     .describe('Delete multiple memories');
+const RELATIONSHIP_ENDPOINT_FIELDS = {
+    from_hash: describeHash('Source hash'),
+    to_hash: describeHash('Target hash'),
+    relation_type: RELATION_TYPE_SCHEMA.describe('Relationship type'),
+};
 export const SearchMemoriesInputSchema = z
     .strictObject({
     query: SEARCH_QUERY_SCHEMA.describe('Search query'),
@@ -192,7 +200,7 @@ export const RetrieveContextInputSchema = z
     .describe('Retrieve context within token budget');
 export const GetRelationshipsInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
     direction: z
         .enum(['outgoing', 'incoming', 'both'])
         .optional()
@@ -202,16 +210,12 @@ export const GetRelationshipsInputSchema = z
     .describe('Get relationships');
 export const CreateRelationshipInputSchema = z
     .strictObject({
-    from_hash: HASH_SCHEMA.describe('Source hash'),
-    to_hash: HASH_SCHEMA.describe('Target hash'),
-    relation_type: RELATION_TYPE_SCHEMA.describe('Relationship type'),
+    ...RELATIONSHIP_ENDPOINT_FIELDS,
 })
     .describe('Create relationship');
 export const DeleteRelationshipInputSchema = z
     .strictObject({
-    from_hash: HASH_SCHEMA.describe('Source hash'),
-    to_hash: HASH_SCHEMA.describe('Target hash'),
-    relation_type: RELATION_TYPE_SCHEMA.describe('Relationship type'),
+    ...RELATIONSHIP_ENDPOINT_FIELDS,
 })
     .describe('Delete relationship');
 export const MemoryStatsInputSchema = z