@persistio/openclaw-plugin 0.1.5 → 0.1.6

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.5",
+  "version": "0.1.6",
   "kind": "memory",
   "activation": {
     "onStartup": true
@@ -39,6 +39,64 @@
       "recallTimeout": {
         "type": "number"
       },
+      "ingest": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "timeoutMs": {
+            "type": "number"
+          },
+          "maxChunkChars": {
+            "type": "number"
+          },
+          "maxChunksPerTurn": {
+            "type": "number"
+          },
+          "skipSubagentSessions": {
+            "type": "boolean"
+          },
+          "user": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "maxCharsPerMessage": {
+                "type": "number"
+              }
+            }
+          },
+          "agent": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "mode": {
+                "type": "string",
+                "enum": [
+                  "bounded",
+                  "raw"
+                ]
+              },
+              "maxCharsPerMessage": {
+                "type": "number"
+              },
+              "maxCharsAfterFiltering": {
+                "type": "number"
+              },
+              "maxCharsPerTurn": {
+                "type": "number"
+              },
+              "largeBlockThresholdChars": {
+                "type": "number"
+              },
+              "largeBlockThresholdLines": {
+                "type": "number"
+              },
+              "maxTableRows": {
+                "type": "number"
+              }
+            }
+          }
+        }
+      },
       "send": {
         "type": "object",
         "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@persistio/openclaw-plugin",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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": "node test/config-schema.test.mjs"
+    "test": "npm run build && node test/config-schema.test.mjs && node test/ingest-policy.test.mjs"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.0"

package/src/client.ts

@@ -1,3 +1,5 @@
+import type { PersistioIngestPolicy } from './ingest-policy.js';
+
 export interface PersistioConfig {
   baseURL: string;
   apiKey: string;
@@ -5,6 +7,7 @@ export interface PersistioConfig {
   recallTopK: number;
   recallMinSimilarity?: number;
   recallTimeout: number;
+  ingest: PersistioIngestPolicy;
   send: PersistioSendConfig;
 }
 
@@ -55,6 +58,7 @@ export class PersistioClient {
   private readonly recallTopK: number;
   private readonly recallMinSimilarity?: number;
   private readonly recallTimeout: number;
+  private readonly ingestTimeout: number;
 
   constructor(config: PersistioConfig) {
     this.baseURL = config.baseURL.replace(/\/$/, '');
@@ -62,6 +66,7 @@ export class PersistioClient {
     this.recallTopK = config.recallTopK;
     this.recallMinSimilarity = config.recallMinSimilarity;
     this.recallTimeout = config.recallTimeout;
+    this.ingestTimeout = config.ingest.timeoutMs;
   }
 
   private headers(): Record<string, string> {
@@ -111,8 +116,9 @@ export class PersistioClient {
       method: 'POST',
       headers: this.headers(),
       body: JSON.stringify({ session_id: sessionId, chunks }),
+      signal: AbortSignal.timeout(this.ingestTimeout),
     });
-    if (!res.ok) throw new Error(`Persistio ingest failed: ${res.status}`);
+    if (!res.ok) throw new Error(await formatHttpError('ingest', res));
   }
 
   async addMemory(data: string, subject: string): Promise<void> {
@@ -151,3 +157,16 @@ export class PersistioClient {
     return data.items ?? [];
   }
 }
+
+async function formatHttpError(operation: string, res: Response): Promise<string> {
+  let detail = '';
+  try {
+    detail = (await res.text()).trim().slice(0, 500);
+  } catch {
+    // Ignore response body read failures; the status is still actionable.
+  }
+
+  return detail
+    ? `Persistio ${operation} failed: ${res.status} ${detail}`
+    : `Persistio ${operation} failed: ${res.status}`;
+}

package/src/index.ts

@@ -7,8 +7,13 @@ import type {
 } from 'openclaw/plugin-sdk/memory-core-host-engine-storage';
 import { Type } from '@sinclair/typebox';
 import { PersistioClient, type PersistioConfig, type PersistioMemory, type RecallBundle } from './client.js';
-
-type OpenClawMessageRole = 'user' | 'assistant' | 'tool';
+import {
+  prepareMessageForIngest,
+  resolveIngestPolicy,
+  shouldIngestSession,
+  type OpenClawMessageRole,
+  type OmissionSummary,
+} from './ingest-policy.js';
 
 interface SessionMessageKeyStore {
   keys: Set<string>;
@@ -58,6 +63,7 @@ function resolveConfig(raw: unknown): PersistioConfig {
     recallTopK: typeof c['recallTopK'] === 'number' ? c['recallTopK'] : 10,
     recallMinSimilarity: resolveRecallMinSimilarity(c['recallMinSimilarity']),
     recallTimeout: typeof c['recallTimeout'] === 'number' ? c['recallTimeout'] : 5000,
+    ingest: resolveIngestPolicy(c['ingest']),
     send: resolveSendConfig(c),
   };
 }
@@ -303,6 +309,26 @@ function forgetKeys(target: Set<string>, keys: string[]): void {
   for (const key of keys) target.delete(key);
 }
 
+function summarizeOmissions(omissions: OmissionSummary[]): string {
+  if (omissions.length === 0) return 'none';
+  const counts = new Map<string, number>();
+  for (const omission of omissions) {
+    counts.set(omission.label, (counts.get(omission.label) ?? 0) + 1);
+  }
+  return [...counts.entries()]
+    .map(([label, count]) => `${label}:${count}`)
+    .join(',');
+}
+
+function isTimeoutLikeError(err: unknown): boolean {
+  if (typeof err !== 'object' || err === null) return false;
+  const record = err as Record<string, unknown>;
+  const name = typeof record['name'] === 'string' ? record['name'] : '';
+  if (name === 'TimeoutError' || name === 'AbortError') return true;
+  const message = typeof record['message'] === 'string' ? record['message'].toLowerCase() : '';
+  return message.includes('timeout') || message.includes('aborted');
+}
+
 const PERSISTIO_MEMORY_PATH_PREFIX = 'persistio://memory/';
 
 function createClient(config: PersistioConfig, recallTopK = config.recallTopK): PersistioClient {
@@ -503,8 +529,18 @@ export default definePluginEntry({
       try {
         const sessionId = context?.sessionId ?? event.runId ?? 'unknown-session';
         if (sessionId.startsWith('announce:')) return;
+        if (!shouldIngestSession(sessionId, cfg.ingest)) {
+          api.logger?.debug?.(`openclaw-persistio: ingest skipped non-main session: ${sessionId}`);
+          return;
+        }
         const chunks: Array<{ role: string; content: string; timestamp: string }> = [];
         const chunkKeys: string[] = [];
+        let agentCharsSent = 0;
+        let originalChars = 0;
+        let preparedChars = 0;
+        let truncatedMessages = 0;
+        let skippedMessages = 0;
+        const omissions: OmissionSummary[] = [];
         const now = Date.now();
         const sentKeys = getSessionKeyStore(sentMessageKeysBySession, sessionId, now);
         const pendingKeys = getSessionKeyStore(pendingMessageKeysBySession, sessionId, now);
@@ -520,17 +556,55 @@ export default definePluginEntry({
           if (sentKeys.has(key) || pendingKeys.has(key)) continue;
 
           const ts = resolveMessageTimestamp(m) ?? new Date().toISOString();
+          const prepared = prepareMessageForIngest({
+            role,
+            text,
+            policy: cfg.ingest,
+            remainingAgentChars: Math.max(0, cfg.ingest.agent.maxCharsPerTurn - agentCharsSent),
+            remainingChunks: Math.max(0, cfg.ingest.maxChunksPerTurn - chunks.length),
+          });
+
+          originalChars += prepared.originalChars;
+          preparedChars += prepared.preparedChars;
+          omissions.push(...prepared.omissions);
+          if (prepared.truncated) truncatedMessages += 1;
+          if (prepared.chunks.length === 0) {
+            skippedMessages += 1;
+            continue;
+          }
+
           chunkKeys.push(key);
-          chunks.push({ role, content: text, timestamp: ts });
+          if (role === 'assistant') {
+            agentCharsSent += prepared.preparedChars;
+          }
+          chunks.push(...prepared.chunks.map((content) => ({ role, content, timestamp: ts })));
+
+          if (chunks.length >= cfg.ingest.maxChunksPerTurn) break;
         }
 
         if (chunks.length === 0) return;
+        if (truncatedMessages > 0 || omissions.length > 0 || skippedMessages > 0) {
+          api.logger?.info?.(
+            `openclaw-persistio: ingest planned session=${sessionId} chunks=${chunks.length} `
+            + `originalChars=${originalChars} preparedChars=${preparedChars} `
+            + `truncatedMessages=${truncatedMessages} skippedMessages=${skippedMessages} `
+            + `omissions=${summarizeOmissions(omissions)}`,
+          );
+        }
         rememberKeys(pendingKeys, chunkKeys);
         client.ingest(sessionId, chunks)
           .then(() => {
             rememberKeys(sentKeys, chunkKeys, MAX_SENT_KEYS_PER_SESSION);
           })
           .catch((err: unknown) => {
+            if (isTimeoutLikeError(err)) {
+              rememberKeys(sentKeys, chunkKeys, MAX_SENT_KEYS_PER_SESSION);
+              api.logger?.warn?.(
+                `openclaw-persistio: ingest timeout after ${cfg.ingest.timeoutMs}ms; `
+                + `outcome is ambiguous, suppressing retry for ${chunkKeys.length} messages in session=${sessionId}`,
+              );
+              return;
+            }
             api.logger?.warn?.(`openclaw-persistio: ingest error: ${String(err)}`);
           })
           .finally(() => {