@persistio/openclaw-plugin 0.1.6 → 0.1.8

package/dist/index.js

@@ -10,6 +10,37 @@ const DEFAULT_SEND_ROLES = {
 const MESSAGE_KEY_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_TRACKED_SESSIONS = 250;
 const MAX_SENT_KEYS_PER_SESSION = 2000;
+const RECALL_CIRCUIT_BREAKER_FAILURE_THRESHOLD = 3;
+const RECALL_CIRCUIT_BREAKER_COOLDOWN_MS = 60_000;
+const RECALL_GUARD_MARGIN_MS = 250;
+const DEFAULT_TOKEN_BUDGET = 400;
+const DEFAULT_RECALL_TOP_K = 4;
+const DEFAULT_RECALL_TIMEOUT_MS = 1500;
+const MAX_MEMORY_SEARCH_RESULTS = 8;
+const MAX_PROMPT_MEMORY_ITEM_CHARS = 500;
+const MAX_MEMORY_SNIPPET_CHARS = 360;
+class RecallCircuitBreaker {
+    consecutiveFailures = 0;
+    openedUntil = 0;
+    canAttempt(now = Date.now()) {
+        return now >= this.openedUntil;
+    }
+    remainingMs(now = Date.now()) {
+        return Math.max(0, this.openedUntil - now);
+    }
+    recordSuccess() {
+        this.consecutiveFailures = 0;
+        this.openedUntil = 0;
+    }
+    recordFailure(now = Date.now()) {
+        this.consecutiveFailures += 1;
+        if (this.consecutiveFailures >= RECALL_CIRCUIT_BREAKER_FAILURE_THRESHOLD) {
+            this.openedUntil = now + RECALL_CIRCUIT_BREAKER_COOLDOWN_MS;
+            return true;
+        }
+        return false;
+    }
+}
 function resolveSendConfig(raw) {
     const send = raw['send'];
     const roles = typeof send === 'object' && send !== null
@@ -31,15 +62,33 @@ function resolveRecallMinSimilarity(value) {
         ? value
         : undefined;
 }
+function resolvePositiveInteger(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1
+        ? Math.floor(value)
+        : fallback;
+}
+function resolveBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function resolveOptionalPositiveInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 1
+        ? Math.floor(value)
+        : undefined;
+}
+function clampPositiveInteger(value, min, max) {
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
 function resolveConfig(raw) {
     const c = (raw ?? {});
     return {
         baseURL: typeof c['baseURL'] === 'string' ? c['baseURL'] : '',
         apiKey: typeof c['apiKey'] === 'string' ? c['apiKey'] : '',
-        tokenBudget: typeof c['tokenBudget'] === 'number' ? c['tokenBudget'] : 2000,
-        recallTopK: typeof c['recallTopK'] === 'number' ? c['recallTopK'] : 10,
+        tokenBudget: resolvePositiveInteger(c['tokenBudget'], DEFAULT_TOKEN_BUDGET),
+        recallTopK: resolvePositiveInteger(c['recallTopK'], DEFAULT_RECALL_TOP_K),
         recallMinSimilarity: resolveRecallMinSimilarity(c['recallMinSimilarity']),
-        recallTimeout: typeof c['recallTimeout'] === 'number' ? c['recallTimeout'] : 5000,
+        recallTimeout: resolvePositiveInteger(c['recallTimeout'], DEFAULT_RECALL_TIMEOUT_MS),
+        recallIncludePending: resolveBoolean(c['recallIncludePending'], false),
+        includeRelatedMemories: resolveBoolean(c['includeRelatedMemories'], false),
         ingest: resolveIngestPolicy(c['ingest']),
         send: resolveSendConfig(c),
     };
@@ -110,20 +159,27 @@ function buildRecallQuery(event) {
     parts.push(`[task: ${taskType}]`);
     return truncate(parts.join('\n'), 600);
 }
+function toStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+}
 function buildMemoryBlock(bundle, budget, relatedBundle) {
+    if (!bundle || typeof bundle !== 'object')
+        return '';
     const sections = [
-        { title: 'Behavioural rules', items: bundle.user_rules },
-        { title: 'Preferences', items: bundle.user_preferences },
-        { title: 'Task patterns', items: bundle.task_patterns },
-        { title: 'Workflows', items: bundle.workflows },
-        { title: 'Project', items: bundle.project },
-        { title: 'Constraints', items: bundle.constraints },
-        { title: 'Decisions', items: bundle.decisions },
-        { title: 'System facts', items: bundle.system_facts },
-        { title: 'Domain knowledge', items: bundle.domain_knowledge },
+        { title: 'Behavioural rules', items: [...toStringArray(bundle.global_user_rules), ...toStringArray(bundle.user_rules)] },
+        { title: 'Preferences', items: toStringArray(bundle.user_preferences) },
+        { title: 'Task patterns', items: toStringArray(bundle.task_patterns) },
+        { title: 'Workflows', items: toStringArray(bundle.workflows) },
+        { title: 'Project', items: toStringArray(bundle.project) },
+        { title: 'Constraints', items: toStringArray(bundle.constraints) },
+        { title: 'Decisions', items: toStringArray(bundle.decisions) },
+        { title: 'System facts', items: toStringArray(bundle.system_facts) },
+        { title: 'Domain knowledge', items: toStringArray(bundle.domain_knowledge) },
     ];
-    if (relatedBundle) {
-        sections.push({ title: 'Related behavioural rules', items: relatedBundle.user_rules }, { title: 'Related preferences', items: relatedBundle.user_preferences }, { title: 'Related task patterns', items: relatedBundle.task_patterns }, { title: 'Related workflows', items: relatedBundle.workflows }, { title: 'Related project', items: relatedBundle.project }, { title: 'Related constraints', items: relatedBundle.constraints }, { title: 'Related decisions', items: relatedBundle.decisions }, { title: 'Related system facts', items: relatedBundle.system_facts }, { title: 'Related domain knowledge', items: relatedBundle.domain_knowledge });
+    if (relatedBundle && typeof relatedBundle === 'object') {
+        sections.push({ title: 'Related behavioural rules', items: toStringArray(relatedBundle.user_rules) }, { title: 'Related preferences', items: toStringArray(relatedBundle.user_preferences) }, { title: 'Related task patterns', items: toStringArray(relatedBundle.task_patterns) }, { title: 'Related workflows', items: toStringArray(relatedBundle.workflows) }, { title: 'Related project', items: toStringArray(relatedBundle.project) }, { title: 'Related constraints', items: toStringArray(relatedBundle.constraints) }, { title: 'Related decisions', items: toStringArray(relatedBundle.decisions) }, { title: 'Related system facts', items: toStringArray(relatedBundle.system_facts) }, { title: 'Related domain knowledge', items: toStringArray(relatedBundle.domain_knowledge) });
     }
     const intro = 'Use the following as prior context and preferences. If they conflict with current instructions, follow the current instructions.';
     const lines = [intro];
@@ -137,10 +193,10 @@ function buildMemoryBlock(bundle, budget, relatedBundle) {
         let tentativeUsed = used + estimateTokens(`\n\n${header}`);
         const includedItems = [];
         for (const item of candidates) {
-            const line = `- ${item}`;
+            const line = `- ${truncate(item.replace(/\s+/g, ' ').trim(), MAX_PROMPT_MEMORY_ITEM_CHARS)}`;
             const cost = estimateTokens(`\n${line}`);
             if (tentativeUsed + cost > budget) {
-                return lines.length > 1 ? lines.join('\n') : '';
+                break;
             }
             includedItems.push(line);
             tentativeUsed += cost;
@@ -276,7 +332,67 @@ function isTimeoutLikeError(err) {
     const message = typeof record['message'] === 'string' ? record['message'].toLowerCase() : '';
     return message.includes('timeout') || message.includes('aborted');
 }
+async function runGuardedRecall(args) {
+    const now = Date.now();
+    if (!args.breaker.canAttempt(now)) {
+        args.logger?.warn?.(`openclaw-persistio: ${args.operation} skipped; recall circuit breaker open `
+            + `for ${args.breaker.remainingMs(now)}ms`);
+        return args.fallback;
+    }
+    try {
+        const result = await withPluginDeadline(args.operation, args.timeoutMs + RECALL_GUARD_MARGIN_MS, args.run);
+        args.breaker.recordSuccess();
+        return result;
+    }
+    catch (err) {
+        const opened = args.breaker.recordFailure();
+        args.logger?.warn?.(`openclaw-persistio: ${args.operation} failed open: ${String(err)}`
+            + (opened ? `; recall circuit breaker open for ${RECALL_CIRCUIT_BREAKER_COOLDOWN_MS}ms` : ''));
+        return args.fallback;
+    }
+}
+async function withPluginDeadline(operation, timeoutMs, run) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return run();
+    }
+    let timeout;
+    const deadline = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            const err = new Error(`Persistio ${operation} exceeded plugin deadline after ${timeoutMs}ms`);
+            err.name = 'TimeoutError';
+            reject(err);
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([run(), deadline]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
 const PERSISTIO_MEMORY_PATH_PREFIX = 'persistio://memory/';
+function jsonResult(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        details: payload,
+    };
+}
+function buildMemorySearchUnavailableResult(error) {
+    return {
+        results: [],
+        disabled: true,
+        unavailable: true,
+        error,
+        warning: 'Persistio memory retrieval is currently unavailable.',
+        action: 'Continue without memory for this turn.',
+        debug: { backend: 'builtin', provider: 'persistio' },
+    };
+}
+function resolveMemorySearchLimit(params) {
+    const requested = resolveOptionalPositiveInteger(params.maxResults) ?? params.fallback;
+    return clampPositiveInteger(requested, 1, MAX_MEMORY_SEARCH_RESULTS);
+}
 function createClient(config, recallTopK = config.recallTopK) {
     return new PersistioClient({ ...config, recallTopK });
 }
@@ -318,16 +434,23 @@ async function probePersistio(client) {
         return { ok: false, error: String(err) };
     }
 }
-function createMemorySearchManager(config) {
+function createMemorySearchManager(config, recallBreaker, logger) {
     const client = createClient(config);
     return {
         async search(query, opts) {
             if (opts?.sources && !opts.sources.includes('memory')) {
                 return [];
             }
-            const recallTopK = typeof opts?.maxResults === 'number' ? opts.maxResults : config.recallTopK;
+            const recallTopK = resolveMemorySearchLimit({ maxResults: opts?.maxResults, fallback: config.recallTopK });
             const recallClient = createClient(config, recallTopK);
-            const memories = await recallClient.recall(query);
+            const memories = await runGuardedRecall({
+                operation: 'memory search recall',
+                timeoutMs: config.recallTimeout,
+                fallback: [],
+                breaker: recallBreaker,
+                logger,
+                run: () => recallClient.recall(query),
+            });
             return memories
                 .map((memory) => {
                 const score = normalizeMemoryScore(memory);
@@ -337,7 +460,7 @@ function createMemorySearchManager(config) {
                     endLine: 1,
                     score,
                     vectorScore: typeof memory.similarity === 'number' ? memory.similarity : undefined,
-                    snippet: truncate(memory.data, 400),
+                    snippet: truncate(memory.data.replace(/\s+/g, ' ').trim(), MAX_MEMORY_SNIPPET_CHARS),
                     source: 'memory',
                     citation: memory.subject,
                 };
@@ -354,12 +477,17 @@ function createMemorySearchManager(config) {
                 throw new Error(`Persistio memory not found: ${memoryId}`);
             }
             const text = formatMemoryDocument(memory);
+            const from = params.from ?? 1;
+            const lines = text.split('\n');
+            const startIndex = Math.max(0, from - 1);
+            const requestedLines = params.lines && params.lines > 0 ? params.lines : 40;
+            const sliced = lines.slice(startIndex, startIndex + requestedLines).join('\n');
             return {
                 path: params.relPath,
-                text,
-                truncated: false,
-                from: params.from ?? 1,
-                lines: params.lines,
+                text: truncate(sliced, 2000),
+                truncated: startIndex + requestedLines < lines.length || sliced.length > 2000,
+                from,
+                lines: requestedLines,
             };
         },
         status() {
@@ -384,11 +512,11 @@ function createMemorySearchManager(config) {
         },
     };
 }
-function createMemoryRuntime(config) {
+function createMemoryRuntime(config, recallBreaker, logger) {
     return {
         async getMemorySearchManager() {
             return {
-                manager: createMemorySearchManager(config),
+                manager: createMemorySearchManager(config, recallBreaker, logger),
             };
         },
         resolveMemoryBackendConfig() {
@@ -396,6 +524,24 @@ function createMemoryRuntime(config) {
         },
     };
 }
+function buildPersistioMemoryPromptSection({ availableTools }) {
+    const hasMemorySearch = availableTools.has('memory_search');
+    const hasMemoryGet = availableTools.has('memory_get');
+    if (!hasMemorySearch && !hasMemoryGet)
+        return [];
+    if (hasMemorySearch && hasMemoryGet) {
+        return [
+            '## Memory Recall',
+            'Persistio is the active memory provider. For prior work, decisions, dates, people, preferences, or todos, use memory_search first and memory_get only for a bounded exact read of a returned persistio://memory/<id> path.',
+            '',
+        ];
+    }
+    return [
+        '## Memory Recall',
+        'Persistio is the active memory provider. Use the available memory tool for prior work, decisions, dates, people, preferences, or todos when memory context is needed.',
+        '',
+    ];
+}
 export default definePluginEntry({
     id: 'openclaw-persistio',
     name: 'Persistio Memory',
@@ -407,10 +553,12 @@ export default definePluginEntry({
             return;
         }
         const client = createClient(cfg);
+        const recallBreaker = new RecallCircuitBreaker();
         const sentMessageKeysBySession = new Map();
         const pendingMessageKeysBySession = new Map();
         api.registerMemoryCapability({
-            runtime: createMemoryRuntime(cfg),
+            promptBuilder: buildPersistioMemoryPromptSection,
+            runtime: createMemoryRuntime(cfg, recallBreaker, api.logger),
         });
         // -------------------------------------------------------------------------
         // before_prompt_build — recall relevant memories and inject into context
@@ -418,18 +566,22 @@ export default definePluginEntry({
         // Return: { appendSystemContext?: string }
         // -------------------------------------------------------------------------
         api.on('before_prompt_build', async (event) => {
-            try {
-                const query = buildRecallQuery(event);
-                const recall = await client.recallBundle(query);
-                const block = buildMemoryBlock(recall.bundle, cfg.tokenBudget, recall.related_bundle);
-                if (!block)
-                    return;
-                return { appendSystemContext: block };
-            }
-            catch (err) {
-                api.logger?.warn?.(`openclaw-persistio: recall error: ${String(err)}`);
-            }
-        });
+            const query = buildRecallQuery(event);
+            const block = await runGuardedRecall({
+                operation: 'before_prompt_build recall',
+                timeoutMs: cfg.recallTimeout,
+                fallback: '',
+                breaker: recallBreaker,
+                logger: api.logger,
+                run: async () => {
+                    const recall = await client.recallBundle(query, undefined, { includeRelated: cfg.includeRelatedMemories });
+                    return buildMemoryBlock(recall.bundle, cfg.tokenBudget, cfg.includeRelatedMemories ? recall.related_bundle : undefined);
+                },
+            });
+            if (!block)
+                return;
+            return { appendSystemContext: block };
+        }, { timeoutMs: cfg.recallTimeout + RECALL_GUARD_MARGIN_MS + 250 });
         // -------------------------------------------------------------------------
         // agent_end — ingest new turn messages (fire and forget)
         // Event: { runId?, messages: unknown[], success: boolean, error?, durationMs? }
@@ -527,44 +679,131 @@ export default definePluginEntry({
         // execute(_id: string, params: unknown): Promise<AgentToolResult>
         // AgentToolResult: { content: Array<{ type: "text", text: string }>, details: unknown }
         // -------------------------------------------------------------------------
+        const memoryManager = createMemorySearchManager(cfg, recallBreaker, api.logger);
         api.registerTool({
             name: 'memory_search',
-            label: 'Search Memory',
-            description: 'Search persistent memory for relevant facts from past conversations.',
+            label: 'Memory Search',
+            description: 'Search Persistio semantic memory. Returns bounded structured results with persistio://memory/<id> paths for memory_get.',
             parameters: Type.Object({
-                query: Type.String({ description: 'What to search for' }),
-                top_k: Type.Optional(Type.Number({ description: 'Max results to return' })),
-            }),
+                query: Type.String({ description: 'Search query' }),
+                maxResults: Type.Optional(Type.Number({ description: 'Maximum results to return' })),
+                minScore: Type.Optional(Type.Number({ description: 'Optional minimum score from 0 to 1' })),
+                corpus: Type.Optional(Type.Union([
+                    Type.Literal('memory'),
+                    Type.Literal('wiki'),
+                    Type.Literal('all'),
+                    Type.Literal('sessions'),
+                ], { description: 'Persistio supports memory corpus results' })),
+            }, { additionalProperties: false }),
             async execute(_id, params) {
                 const p = params;
-                const overrideTopK = typeof p.top_k === 'number' ? p.top_k : cfg.recallTopK;
-                const overrideCfg = { ...cfg, recallTopK: overrideTopK };
-                const c = new PersistioClient(overrideCfg);
-                const memories = await c.recall(p.query);
-                const text = memories.length > 0
-                    ? memories.map(m => `- ${m.data} [${m.subject}]`).join('\n')
-                    : 'No memories found.';
-                return { content: [{ type: 'text', text }], details: null };
+                const query = typeof p.query === 'string' ? p.query.trim() : '';
+                if (!query) {
+                    return jsonResult(buildMemorySearchUnavailableResult('memory_search requires a non-empty query'));
+                }
+                const maxResults = resolveMemorySearchLimit({
+                    maxResults: p.maxResults,
+                    fallback: cfg.recallTopK,
+                });
+                const requestedCorpus = p.corpus ?? 'memory';
+                const sources = requestedCorpus === 'sessions' || requestedCorpus === 'wiki'
+                    ? []
+                    : ['memory'];
+                const startedAt = Date.now();
+                try {
+                    const results = sources.length === 0
+                        ? []
+                        : await memoryManager.search(query, {
+                            maxResults,
+                            minScore: p.minScore,
+                            sources,
+                        });
+                    return jsonResult({
+                        results: results.map((result) => ({ ...result, corpus: 'memory' })),
+                        provider: 'persistio',
+                        model: undefined,
+                        fallback: false,
+                        citations: 'off',
+                        mode: 'persistio',
+                        debug: {
+                            backend: 'builtin',
+                            effectiveMode: 'persistio',
+                            requestedCorpus,
+                            searchMs: Math.max(0, Date.now() - startedAt),
+                            hits: results.length,
+                        },
+                    });
+                }
+                catch (err) {
+                    return jsonResult(buildMemorySearchUnavailableResult(String(err)));
+                }
+            },
+        });
+        api.registerTool({
+            name: 'memory_get',
+            label: 'Memory Get',
+            description: 'Read a bounded exact Persistio memory document by persistio://memory/<id> path.',
+            parameters: Type.Object({
+                path: Type.String({ description: 'Memory path returned by memory_search' }),
+                from: Type.Optional(Type.Number({ description: 'Starting line, 1-based' })),
+                lines: Type.Optional(Type.Number({ description: 'Maximum number of lines to return' })),
+                corpus: Type.Optional(Type.Union([
+                    Type.Literal('memory'),
+                    Type.Literal('wiki'),
+                    Type.Literal('all'),
+                ])),
+            }, { additionalProperties: false }),
+            async execute(_id, params) {
+                const p = params;
+                const path = typeof p.path === 'string' ? p.path : '';
+                if (p.corpus === 'wiki') {
+                    return jsonResult({ path, text: '', disabled: true, error: 'Persistio does not provide a wiki corpus' });
+                }
+                try {
+                    return jsonResult(await memoryManager.readFile({
+                        relPath: path,
+                        from: resolveOptionalPositiveInteger(p.from),
+                        lines: resolveOptionalPositiveInteger(p.lines),
+                    }));
+                }
+                catch (err) {
+                    return jsonResult({ path, text: '', disabled: true, error: String(err) });
+                }
             },
         });
         api.registerTool({
-            name: 'memory_add',
-            label: 'Add Memory',
-            description: 'Manually store a fact in persistent memory.',
+            name: 'persistio_memory_add',
+            label: 'Add Persistio Memory',
+            description: 'Manually store a fact in Persistio memory.',
             parameters: Type.Object({
                 data: Type.String({ description: 'The fact to remember' }),
                 subject: Type.String({ description: 'The entity or topic this fact is about' }),
             }),
             async execute(_id, params) {
                 const p = params;
-                await client.addMemory(p.data, p.subject);
+                try {
+                    await client.addMemory(p.data, p.subject);
+                }
+                catch (err) {
+                    if (isTimeoutLikeError(err)) {
+                        api.logger?.warn?.(`openclaw-persistio: persistio_memory_add timeout after ${cfg.ingest.timeoutMs}ms; outcome is ambiguous`);
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: 'Memory store request timed out; it may still complete. Check persistio_memory_list before retrying.',
+                                }],
+                            details: { ambiguous: true },
+                        };
+                    }
+                    throw err;
+                }
                 return { content: [{ type: 'text', text: 'Memory stored.' }], details: null };
             },
-        });
+        }, { optional: true });
         api.registerTool({
-            name: 'memory_delete',
-            label: 'Delete Memory',
-            description: 'Delete a specific memory by its ID.',
+            name: 'persistio_memory_delete',
+            label: 'Delete Persistio Memory',
+            description: 'Delete a specific Persistio memory by its ID.',
             parameters: Type.Object({
                 id: Type.String({ description: 'The memory ID to delete' }),
             }),
@@ -575,14 +814,14 @@ export default definePluginEntry({
             },
         }, { optional: true });
         api.registerTool({
-            name: 'memory_list',
-            label: 'List Memories',
-            description: 'List all stored memories.',
+            name: 'persistio_memory_list',
+            label: 'List Persistio Memories',
+            description: 'List stored Persistio memories.',
             parameters: Type.Object({}),
             async execute(_id, _params) {
                 const memories = await client.listMemories();
                 const text = memories.length > 0
-                    ? memories.map(m => `[${m.id}] ${m.data} (${m.subject})`).join('\n')
+                    ? memories.map(m => `[${m.id}] ${truncate(m.data.replace(/\s+/g, ' ').trim(), MAX_MEMORY_SNIPPET_CHARS)} (${m.subject})`).join('\n')
                     : 'No memories stored.';
                 return { content: [{ type: 'text', text }], details: null };
             },

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-persistio",
   "name": "Persistio Memory",
   "description": "Persistent semantic memory for OpenClaw via Persistio",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "kind": "memory",
   "activation": {
     "onStartup": true
@@ -10,11 +10,23 @@
   "contracts": {
     "tools": [
       "memory_search",
-      "memory_add",
-      "memory_delete",
-      "memory_list"
+      "memory_get",
+      "persistio_memory_add",
+      "persistio_memory_delete",
+      "persistio_memory_list"
     ]
   },
+  "toolMetadata": {
+    "persistio_memory_add": {
+      "optional": true
+    },
+    "persistio_memory_delete": {
+      "optional": true
+    },
+    "persistio_memory_list": {
+      "optional": true
+    }
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -26,10 +38,12 @@
         "type": "string"
       },
       "tokenBudget": {
-        "type": "number"
+        "type": "number",
+        "minimum": 1
       },
       "recallTopK": {
-        "type": "number"
+        "type": "number",
+        "minimum": 1
       },
       "recallMinSimilarity": {
         "type": "number",
@@ -37,20 +51,30 @@
         "maximum": 1
       },
       "recallTimeout": {
-        "type": "number"
+        "type": "number",
+        "minimum": 1
+      },
+      "recallIncludePending": {
+        "type": "boolean"
+      },
+      "includeRelatedMemories": {
+        "type": "boolean"
       },
       "ingest": {
         "type": "object",
         "additionalProperties": false,
         "properties": {
           "timeoutMs": {
-            "type": "number"
+            "type": "number",
+            "minimum": 1
           },
           "maxChunkChars": {
-            "type": "number"
+            "type": "number",
+            "minimum": 256
           },
           "maxChunksPerTurn": {
-            "type": "number"
+            "type": "number",
+            "minimum": 1
           },
           "skipSubagentSessions": {
             "type": "boolean"
@@ -60,7 +84,8 @@
             "additionalProperties": false,
             "properties": {
               "maxCharsPerMessage": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               }
             }
           },
@@ -76,22 +101,28 @@
                 ]
               },
               "maxCharsPerMessage": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               },
               "maxCharsAfterFiltering": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               },
               "maxCharsPerTurn": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               },
               "largeBlockThresholdChars": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               },
               "largeBlockThresholdLines": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               },
               "maxTableRows": {
-                "type": "number"
+                "type": "number",
+                "minimum": 1
               }
             }
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@persistio/openclaw-plugin",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "OpenClaw plugin for Persistio \u2014 persistent semantic memory for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,7 +42,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node test/config-schema.test.mjs && node test/ingest-policy.test.mjs"
+    "test": "npm run build && node test/config-schema.test.mjs && node test/ingest-policy.test.mjs && node test/client-timeout.test.mjs"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.0"