@j0hanz/memory-mcp 1.3.0 → 1.4.0

package/dist/prompts/index.js

@@ -19,14 +19,13 @@ function createHelpMessages(instructions) {
     ];
 }
 const HELP_MESSAGES = createHelpMessages(INSTRUCTIONS_CONTENT);
+const GET_HELP_PROMPT_NAME = 'get-help';
 const GET_HELP_PROMPT_CONFIG = {
     title: 'Get Help',
     description: 'Return full usage instructions.',
 };
-const GET_HELP_PROMPT_NAME = 'get-help';
 export function registerAllPrompts(server) {
     server.registerPrompt(GET_HELP_PROMPT_NAME, GET_HELP_PROMPT_CONFIG, () => ({
         messages: HELP_MESSAGES,
     }));
 }
-//# sourceMappingURL=index.js.map

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

package/dist/resources/index.js

@@ -18,6 +18,7 @@ const MEMORY_RESOURCE_URI_TEMPLATE = 'memory://memories/{hash}';
 const MEMORY_RESOURCE_LIST_LIMIT = 100;
 const RECENT_MEMORY_HASHES_SQL = `SELECT hash FROM memories ORDER BY updated_at DESC LIMIT ${MEMORY_RESOURCE_LIST_LIMIT}`;
 const RESOURCE_LAST_MODIFIED = new Date().toISOString();
+const TOOL_NAMES = getToolNames();
 function createMarkdownContent(uri, text) {
     return { uri, mimeType: 'text/markdown', text };
 }
@@ -33,15 +34,39 @@ function createErrorResourceContents(uri, error, hash) {
         contents: [createJsonContent(uri, { error, ...(hash ? { hash } : {}) })],
     };
 }
+function createResourceAnnotations(audience, priority) {
+    return {
+        audience: [...audience],
+        priority,
+        lastModified: RESOURCE_LAST_MODIFIED,
+    };
+}
 function getSingleVariable(value) {
     return Array.isArray(value) ? value[0] : value;
 }
+function requireSingleVariable(variables, key, errorMessage) {
+    const value = getSingleVariable(variables[key]);
+    if (!value) {
+        throw new McpError(ErrorCode.InvalidParams, errorMessage);
+    }
+    return value;
+}
+function registerStaticMarkdownResource(server, config) {
+    server.registerResource(config.name, config.uri, {
+        title: config.title,
+        description: config.description,
+        mimeType: 'text/markdown',
+        annotations: createResourceAnnotations(config.audience, config.priority),
+    }, () => ({
+        contents: [createMarkdownContent(config.uri, config.content)],
+    }));
+}
 function readMemoryByHash(db, hash) {
     return db.prepareOnce(SELECT_MEMORY_BY_HASH_SQL).get(hash);
 }
 function listToolInfoResources() {
     return {
-        resources: getToolNames().map((toolName) => ({
+        resources: TOOL_NAMES.map((toolName) => ({
             uri: `internal://tool-info/${toolName}`,
             name: 'tool-info',
             title: `Tool Info: ${toolName}`,
@@ -68,51 +93,38 @@ const SERVER_CONFIG_CONTENT = buildServerConfig();
 // --- Registration ---
 export function registerAllResources(server, db) {
     // internal://instructions
-    server.registerResource('instructions', INSTRUCTIONS_URI, {
+    registerStaticMarkdownResource(server, {
+        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.',
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.9,
-            lastModified: RESOURCE_LAST_MODIFIED,
-        },
-    }, () => ({
-        contents: [createMarkdownContent(INSTRUCTIONS_URI, INSTRUCTIONS_CONTENT)],
-    }));
+        audience: ['assistant'],
+        priority: 0.9,
+        content: INSTRUCTIONS_CONTENT,
+    });
     // internal://tool-catalog
-    server.registerResource('tool-catalog', TOOL_CATALOG_URI, {
+    registerStaticMarkdownResource(server, {
+        name: 'tool-catalog',
+        uri: TOOL_CATALOG_URI,
         title: 'Tool Catalog',
         description: 'Tool reference table, optional parameter matrix, and cross-tool data flow.',
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.7,
-            lastModified: RESOURCE_LAST_MODIFIED,
-        },
-    }, () => ({
-        contents: [createMarkdownContent(TOOL_CATALOG_URI, TOOL_CATALOG_CONTENT)],
-    }));
+        audience: ['assistant'],
+        priority: 0.7,
+        content: TOOL_CATALOG_CONTENT,
+    });
     // internal://tool-info/{toolName}
     server.registerResource('tool-info', new ResourceTemplate(TOOL_INFO_URI_TEMPLATE, {
         list: () => listToolInfoResources(),
         complete: {
-            toolName: (value) => getToolNames().filter((n) => n.startsWith(value)),
+            toolName: (value) => TOOL_NAMES.filter((n) => n.startsWith(value)),
         },
     }), {
         title: 'Tool Info',
         description: 'Per-tool detail: parameters, behavior, and output shape. Supports toolName auto-completion.',
         mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.6,
-            lastModified: RESOURCE_LAST_MODIFIED,
-        },
+        annotations: createResourceAnnotations(['assistant'], 0.6),
     }, (uri, variables) => {
-        const toolName = getSingleVariable(variables['toolName']);
-        if (!toolName) {
-            throw new McpError(ErrorCode.InvalidParams, 'Missing toolName parameter');
-        }
+        const toolName = requireSingleVariable(variables, 'toolName', 'Missing toolName parameter');
         const info = getToolInfo(toolName);
         if (!info) {
             throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${toolName}`);
@@ -122,33 +134,25 @@ export function registerAllResources(server, db) {
         };
     });
     // internal://workflows
-    server.registerResource('workflows', WORKFLOWS_URI, {
+    registerStaticMarkdownResource(server, {
+        name: 'workflows',
+        uri: WORKFLOWS_URI,
         title: 'Workflow Guide',
         description: 'Recommended multi-step workflow sequences with guardrails and tool reference.',
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.7,
-            lastModified: RESOURCE_LAST_MODIFIED,
-        },
-    }, () => ({
-        contents: [createMarkdownContent(WORKFLOWS_URI, WORKFLOW_GUIDE_CONTENT)],
-    }));
+        audience: ['assistant'],
+        priority: 0.7,
+        content: WORKFLOW_GUIDE_CONTENT,
+    });
     // internal://server-config
-    server.registerResource('server-config', SERVER_CONFIG_URI, {
+    registerStaticMarkdownResource(server, {
+        name: 'server-config',
+        uri: SERVER_CONFIG_URI,
         title: 'Server Configuration',
         description: 'Runtime configuration, environment variables, capabilities, and data limits.',
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['user', 'assistant'],
-            priority: 0.5,
-            lastModified: RESOURCE_LAST_MODIFIED,
-        },
-    }, () => ({
-        contents: [
-            createMarkdownContent(SERVER_CONFIG_URI, SERVER_CONFIG_CONTENT),
-        ],
-    }));
+        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, {
@@ -158,14 +162,9 @@ export function registerAllResources(server, db) {
         title: 'Memory',
         description: 'Fetch a single memory object by exact SHA-256 hash. Supports hash auto-completion. Returns { error } if the hash does not exist.',
         mimeType: 'application/json',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.7,
-            lastModified: RESOURCE_LAST_MODIFIED,
-        },
+        annotations: createResourceAnnotations(['assistant'], 0.7),
     }, (uri, variables) => {
-        const rawHash = variables['hash'];
-        const hash = getSingleVariable(rawHash);
+        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');
         }
@@ -178,4 +177,3 @@ export function registerAllResources(server, db) {
         };
     });
 }
-//# sourceMappingURL=index.js.map

package/dist/resources/instructions.d.ts

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

package/dist/resources/instructions.js

@@ -17,90 +17,88 @@ const ERROR_CODES = [
     '| `E_CANCELLED` | Request was cancelled |',
     '| `E_UNKNOWN` | Unexpected internal error — retry once |',
 ];
-const DATA_MODEL = `### Memory
-- \`hash\` — SHA-256 of \`(content + sorted tags)\`; deterministic; changes when content or tags change
-- \`content\` — Text; 1–100,000 chars
-- \`tags\` — Array; 1–100 tags; each 1–50 chars, no whitespace; minimum 1 required
-- \`memory_type\` — \`general\` | \`fact\` | \`plan\` | \`decision\` | \`reflection\` | \`lesson\` | \`error\` | \`gradient\` (default \`general\`)
-- \`importance\` — Integer 0–10 (default 0; 10 = critical)
-- \`created_at\`, \`updated_at\` — ISO 8601 timestamps
+const ERROR_RESULT_CONVENTIONS = [
+    '- Tool failures return `isError: true` with JSON text in `content[0].text`.',
+    '- Error payload shape: `{ ok: false, error: { code, message } }`.',
+    '- On error, do not expect `structuredContent`; parse the JSON text payload instead.',
+    '- Successful responses include both `structuredContent` and JSON text in `content[0].text`.',
+];
+const DATA_MODEL = `Memory:
+- hash: SHA-256(content + sorted tags). Deterministic.
+- content: 1-100k chars.
+- tags: 1-100 items, 1-50 chars each.
+- type: general|fact|plan|decision|reflection|lesson|error|gradient.
+- importance: 0-10.
 
-### Relationship
-- Directed edge: \`from_hash -[relation_type]-> to_hash\`
-- \`relation_type\` — Free-form string, 1–50 chars, no whitespace
-- Suggested types: \`related_to\`, \`causes\`, \`depends_on\`, \`parent_of\`, \`child_of\`, \`supersedes\`, \`contradicts\`, \`supports\`, \`references\`
-- Both endpoints must exist before creating a relationship
-- Cascade-deleted when either endpoint memory is deleted
-- Cascade-updated when either endpoint hash changes (ON UPDATE CASCADE)`;
-const WORKFLOWS = `### Store and Link
-\`\`\`
-store_memories({ items: [...] })         → { items[].hash, succeeded, failed }
-create_relationship({ from_hash, to_hash, relation_type })  × N
-\`\`\`
+Relationship:
+- Edge: from_hash -[relation_type]-> to_hash.
+- type: 1-50 chars.
+- Constraint: Endpoints must exist. Cascade delete/update.`;
+const WORKFLOWS = `
+1. Store and Link:
+   store_memories({ items: [...] }) -> { items[].hash }
+   create_relationship({ from_hash, to_hash, relation_type })
 
-### Search and Read
-\`\`\`
-search_memories({ query, limit })        → { memories[], nextCursor }
-# or, for relationship navigation:
-recall({ query, depth: 1 })             → { memories[], graph[] }
-\`\`\`
+2. Search and Read:
+   search_memories({ query, limit }) -> { memories[], nextCursor }
+   recall({ query, depth: 1 }) -> { memories[], graph[] }
 
-### Fill Context Window
-\`\`\`
-retrieve_context({ query, token_budget: 4000, strategy: 'relevance' })
-  → { memories[], estimated_tokens, truncated }
-\`\`\`
+3. Fill Context:
+   retrieve_context({ query, token_budget: 4000 }) -> { memories[], truncated }
 
-### Update a Memory
-\`\`\`
-update_memory({ hash, content })         → { old_hash, new_hash }
-# Existing relationships auto-update to new_hash via CASCADE
-\`\`\`
+4. Update:
+   update_memory({ hash, content }) -> { new_hash }
 
-### Batch Delete
-\`\`\`
-delete_memories({ hashes: [...] })       → { items[].{ hash, deleted }, succeeded, failed }
-# deleted: false means hash not found — not an error
-\`\`\``;
+5. Delete:
+   delete_memories({ hashes: [...] }) -> { items[].deleted }`;
 function buildToolRouting() {
-    const contracts = getToolContracts();
-    const rows = contracts.map((c) => {
+    const rows = getToolContracts().map((c) => {
         const purpose = c.description.split('.')[0] ?? '';
         return `| \`${c.name}\` | ${purpose} |`;
     });
-    return [
-        '## Tool Routing',
-        '',
-        '| Tool | Purpose |',
-        '| --- | --- |',
-        ...rows,
-    ].join('\n');
+    return ['| Tool | Purpose |', '| --- | --- |', ...rows].join('\n');
+}
+function renderSharedConstraints() {
+    return getSharedConstraints()
+        .map((c) => `- ${c}`)
+        .join('\n');
 }
 export function buildServerInstructions() {
     return [
-        '# Memory MCP — Usage Guide',
+        '<role>',
+        'Memory MCP: Persistent memory storage, full-text retrieval, and relationship graph traversal.',
+        '</role>',
         '',
+        '<capabilities>',
         buildToolRouting(),
+        '</capabilities>',
         '',
-        '## Shared Constraints',
-        getSharedConstraints()
-            .map((c) => `- ${c}`)
-            .join('\n'),
+        '<constraints>',
+        renderSharedConstraints(),
+        '</constraints>',
         '',
-        '## Error Codes',
+        '<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,
+        '</data_model>',
         '',
-        '## Common Workflows',
+        '<workflows>',
         WORKFLOWS,
+        '</workflows>',
         '',
-        '## Prompts',
+        '<prompts>',
         PROMPTS_INVENTORY.join('\n'),
+        '</prompts>',
         '',
-        '## Resources',
+        '<resources>',
         RESOURCES_INVENTORY.join('\n'),
+        '</resources>',
     ].join('\n');
 }
-//# sourceMappingURL=instructions.js.map

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

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

package/dist/resources/server-config.js

@@ -1,7 +1,7 @@
 const ENV_VARS = [
     {
         name: 'MEMORY_DB_PATH',
-        default: 'memory.db',
+        default: 'memory_db/memory.db',
         range: '—',
         purpose: 'SQLite database file path',
     },
@@ -38,16 +38,21 @@ const DATA_LIMITS = [
 ];
 const CAPABILITIES = [
     { capability: 'tools', status: 'enabled' },
-    { capability: 'resources', status: 'enabled (subscribe supported)' },
+    { capability: 'resources', status: 'enabled (list/read + listChanged)' },
     { capability: 'prompts', status: 'enabled' },
     { capability: 'completions', status: 'enabled' },
     { capability: 'logging', status: 'enabled' },
-    { capability: 'tasks', status: 'enabled' },
 ];
+function toEnvVarRow(v) {
+    return `| \`${v.name}\` | ${v.default} | ${v.range} | ${v.purpose} |`;
+}
+function toRangeRow(label, range) {
+    return `| ${label} | ${range} |`;
+}
 export function buildServerConfig() {
-    const envRows = ENV_VARS.map((v) => `| \`${v.name}\` | ${v.default} | ${v.range} | ${v.purpose} |`);
-    const limitRows = DATA_LIMITS.map((l) => `| ${l.dimension} | ${l.range} |`);
-    const capRows = CAPABILITIES.map((c) => `| ${c.capability} | ${c.status} |`);
+    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));
     return [
         '# Server Configuration',
         '',
@@ -70,4 +75,3 @@ export function buildServerConfig() {
         ...limitRows,
     ].join('\n');
 }
-//# sourceMappingURL=server-config.js.map

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

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

package/dist/resources/tool-catalog.js

@@ -1,14 +1,6 @@
-import { z } from 'zod/v4';
+import { extractJsonSchema, } from '../lib/json-schema.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 import { buildCoreContextPack } from './tool-info.js';
-function extractJsonSchema(schema) {
-    try {
-        return z.toJSONSchema(schema);
-    }
-    catch {
-        return {};
-    }
-}
 function extractOptionalParams(toolName, schema) {
     const jsonSchema = extractJsonSchema(schema);
     const properties = (jsonSchema['properties'] ?? {});
@@ -26,10 +18,7 @@ function extractOptionalParams(toolName, schema) {
     }
     return rows;
 }
-const CROSS_TOOL_DATA_FLOW = `## Cross-Tool Data Flow
-
-\`\`\`
-store_memory.hash ──→ get_memory.hash
+const CROSS_TOOL_DATA_FLOW = `store_memory.hash ──→ get_memory.hash
 store_memory.hash ──→ create_relationship.from_hash / to_hash
 store_memory.hash ──→ update_memory.hash
 store_memory.hash ──→ delete_memory.hash
@@ -39,18 +28,17 @@ search_memories.nextCursor ──→ search_memories.cursor
 recall.memories[].hash ──→ get_memory.hash
 recall.nextCursor ──→ recall.cursor
 update_memory.new_hash ──→ get_memory.hash
-get_relationships.relationships[].linked_hash ──→ get_memory.hash
-\`\`\``;
+get_relationships.relationships[].linked_hash ──→ get_memory.hash`;
 export function buildToolCatalog() {
     const contracts = getToolContracts();
     const optionalRows = contracts.flatMap((c) => extractOptionalParams(c.name, c.inputSchema));
     const optionalParamSection = optionalRows.length > 0
         ? [
-            '## Optional Parameter Matrix',
-            '',
+            '<optional_params>',
             '| Tool | Parameter | Default | Purpose |',
             '|------|-----------|---------|---------|',
             ...optionalRows,
+            '</optional_params>',
         ].join('\n')
         : '';
     return [
@@ -58,7 +46,8 @@ export function buildToolCatalog() {
         '',
         optionalParamSection,
         '',
+        '<data_flow>',
         CROSS_TOOL_DATA_FLOW,
+        '</data_flow>',
     ].join('\n');
 }
-//# sourceMappingURL=tool-catalog.js.map

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

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

@@ -1,12 +1,12 @@
-import { z } from 'zod/v4';
+import { extractJsonSchema, } from '../lib/json-schema.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 // --- Shared Constraints (Single Source of Truth) ---
 const SHARED_CONSTRAINTS = [
     'Idempotence: `store_memory` and `store_memories` return `created: false` if content+tags exist.',
     'Atomic Transactions: `store_memories` and `delete_memories` roll back on error.',
     'Hash Changes: `update_memory` changes hash on content/tags change. Relationships survive via CASCADE.',
-    'FTS Search Limits: Query terms matched individually (all-OR). No phrase/negation support.',
-    'Recall Limits: BFS traversal bounded by env vars. Returns `aborted: true` with partial results if hit.',
+    'FTS Search Limits: Query is tokenized to alphanumeric/underscore terms and uses implicit AND matching. No phrase/negation support.',
+    'Recall Limits: BFS traversal bounded by env vars. Returns `aborted: true` with partial results only when limits are hit.',
 ];
 export function getSharedConstraints() {
     return SHARED_CONSTRAINTS;
@@ -35,22 +35,14 @@ export function buildCoreContextPack() {
         .sort((a, b) => a.name.localeCompare(b.name));
     const rows = entries.map((e) => `| \`${e.name}\` | ${e.purpose} | ${e.behavior} |`);
     return [
-        '# Core Context Pack',
-        '',
+        '<core_tools>',
         '| Tool | Purpose | Behavior |',
         '|------|---------|----------|',
         ...rows,
+        '</core_tools>',
     ].join('\n');
 }
 // --- Per-Tool Info ---
-function extractJsonSchema(schema) {
-    try {
-        return z.toJSONSchema(schema);
-    }
-    catch {
-        return {};
-    }
-}
 function formatParamConstraints(prop) {
     const parts = [];
     if (typeof prop['minimum'] === 'number')
@@ -106,13 +98,14 @@ export function getToolInfo(name) {
     const behaviorLine = formatBehavior(contract.annotations);
     const outputShape = formatOutputShape(contract.outputSchema);
     return [
-        `### ${contract.name} (${behaviorLine})`,
-        contract.description,
-        '',
-        '**Params:**',
+        `<tool_info name="${contract.name}">`,
+        `<description>${contract.description}</description>`,
+        `<behavior>${behaviorLine}</behavior>`,
+        '<params>',
         paramLines.length > 0 ? paramLines.join('\n') : 'None',
-        '',
-        `**Output:** \`${outputShape}\``,
+        '</params>',
+        `<output>${outputShape}</output>`,
+        '</tool_info>',
     ].join('\n');
 }
 export function getToolNames() {
@@ -120,4 +113,3 @@ export function getToolNames() {
         .map((c) => c.name)
         .sort((a, b) => a.localeCompare(b));
 }
-//# sourceMappingURL=tool-info.js.map

package/dist/resources/workflows.d.ts

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

package/dist/resources/workflows.js

@@ -38,6 +38,11 @@ const WORKFLOW_TRACKS = `## Workflow A: Store and Link
 2. \`get_relationships({ hash, direction: 'both' })\` for a specific memory's edges
 
 > BFS traversal emits progress per hop. Use \`depth: 0\` to skip traversal.`;
+function renderSharedConstraintsSection() {
+    return getSharedConstraints()
+        .map((c) => `- ${c}`)
+        .join('\n');
+}
 export function buildWorkflowGuide() {
     return [
         '# Workflow Reference',
@@ -45,11 +50,8 @@ export function buildWorkflowGuide() {
         WORKFLOW_TRACKS,
         '',
         '## Shared Constraints',
-        getSharedConstraints()
-            .map((c) => `- ${c}`)
-            .join('\n'),
+        renderSharedConstraintsSection(),
         '',
         '> See `internal://tool-catalog` for complete tool reference and cross-tool data flow.',
     ].join('\n');
 }
-//# sourceMappingURL=workflows.js.map

package/dist/schemas/index.d.ts

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

package/dist/schemas/index.js

@@ -1,4 +1,3 @@
-// Public schema module barrel.
+// Public schema barrel for MCP input/output contracts.
 export * from './inputs.js';
 export * from './outputs.js';
-//# sourceMappingURL=index.js.map

package/dist/schemas/inputs.d.ts

@@ -1,5 +1,15 @@
 import { z } from 'zod/v4';
 export declare const HASH_SCHEMA: z.ZodString;
+declare const MEMORY_TYPE_SCHEMA: z.ZodEnum<{
+    error: "error";
+    general: "general";
+    fact: "fact";
+    plan: "plan";
+    decision: "decision";
+    reflection: "reflection";
+    lesson: "lesson";
+    gradient: "gradient";
+}>;
 export declare const SUGGESTED_RELATION_TYPES: readonly ["related_to", "causes", "depends_on", "parent_of", "child_of", "supersedes", "contradicts", "supports", "references"];
 export declare const StoreMemoryInputSchema: z.ZodObject<{
     content: z.ZodString;
@@ -63,39 +73,21 @@ export declare const DeleteMemoriesInputSchema: z.ZodObject<{
     hashes: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export declare const SearchMemoriesInputSchema: z.ZodObject<{
+    min_importance: z.ZodOptional<z.ZodNumber>;
+    max_importance: z.ZodOptional<z.ZodNumber>;
+    memory_type: z.ZodOptional<typeof MEMORY_TYPE_SCHEMA>;
     query: z.ZodString;
     limit: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
     cursor: z.ZodOptional<z.ZodString>;
-    min_importance: z.ZodOptional<z.ZodNumber>;
-    max_importance: z.ZodOptional<z.ZodNumber>;
-    memory_type: z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        general: "general";
-        fact: "fact";
-        plan: "plan";
-        decision: "decision";
-        reflection: "reflection";
-        lesson: "lesson";
-        gradient: "gradient";
-    }>>;
 }, z.core.$strict>;
 export declare const RecallInputSchema: z.ZodObject<{
+    min_importance: z.ZodOptional<z.ZodNumber>;
+    max_importance: z.ZodOptional<z.ZodNumber>;
+    memory_type: z.ZodOptional<typeof MEMORY_TYPE_SCHEMA>;
     query: z.ZodString;
     depth: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
     limit: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
     cursor: z.ZodOptional<z.ZodString>;
-    min_importance: z.ZodOptional<z.ZodNumber>;
-    max_importance: z.ZodOptional<z.ZodNumber>;
-    memory_type: z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        general: "general";
-        fact: "fact";
-        plan: "plan";
-        decision: "decision";
-        reflection: "reflection";
-        lesson: "lesson";
-        gradient: "gradient";
-    }>>;
 }, z.core.$strict>;
 export declare const RetrieveContextInputSchema: z.ZodObject<{
     query: z.ZodString;
@@ -125,4 +117,4 @@ export declare const DeleteRelationshipInputSchema: z.ZodObject<{
     relation_type: z.ZodString;
 }, z.core.$strict>;
 export declare const MemoryStatsInputSchema: z.ZodObject<{}, z.core.$strict>;
-//# sourceMappingURL=inputs.d.ts.map
+export {};