@pentatonic-ai/ai-agent-sdk 0.5.5 → 0.5.7

package/packages/memory/src/openclaw/index.js

@@ -38,6 +38,40 @@
 import pg from "pg";
 import { createMemorySystem } from "../index.js";
 import { createContextEngine } from "./context-engine.js";
+import { sanitizeMemoryContent } from "../sanitize.js";
+import {
+  hostedSearch as _hostedSearch,
+  hostedEmitChatTurn as _hostedEmitChatTurn,
+  hostedStoreMemory as _hostedStoreMemory,
+} from "../hosted.js";
+
+// --- Hosted-mode adapters ---
+//
+// The OpenClaw plugin predates the public hosted-helper API (`packages/
+// memory/src/hosted.js`). The wrappers below adapt the plugin's existing
+// call shape to the public API so other consumers (the LLM proxy worker,
+// custom integrations) hit the same code path. Adapters are tiny — they
+// translate args and unwrap the result envelope. New code should import
+// from `@pentatonic-ai/ai-agent-sdk/memory/hosted` directly.
+
+async function hostedSearch(config, query, limit = 5, minScore = 0.3) {
+  const { memories } = await _hostedSearch(config, query, { limit, minScore });
+  return memories;
+}
+
+async function hostedEmitChatTurn(config, sessionId, turn) {
+  return _hostedEmitChatTurn(
+    config,
+    { ...turn, sessionId },
+    { source: "openclaw-plugin" }
+  );
+}
+
+async function hostedStore(config, content, metadata = {}) {
+  return _hostedStoreMemory(config, content, metadata, {
+    source: metadata.source || "openclaw-plugin",
+  });
+}
 
 const { Pool } = pg;
 
@@ -74,139 +108,6 @@ function getLocalMemory(config) {
   return memory;
 }
 
-// --- Hosted mode helpers ---
-
-function tesHeaders(config) {
-  const headers = {
-    "Content-Type": "application/json",
-    "x-client-id": config.tes_client_id,
-  };
-  if (config.tes_api_key?.startsWith("tes_")) {
-    headers["Authorization"] = `Bearer ${config.tes_api_key}`;
-  } else {
-    headers["x-service-key"] = config.tes_api_key;
-  }
-  return headers;
-}
-
-async function hostedSearch(config, query, limit = 5, minScore = 0.3) {
-  try {
-    const response = await fetch(`${config.tes_endpoint}/api/graphql`, {
-      method: "POST",
-      headers: tesHeaders(config),
-      body: JSON.stringify({
-        query: `query($clientId: String!, $query: String!, $limit: Int, $minScore: Float) {
-          semanticSearchMemories(clientId: $clientId, query: $query, limit: $limit, minScore: $minScore) {
-            id content similarity
-          }
-        }`,
-        variables: {
-          clientId: config.tes_client_id,
-          query,
-          limit,
-          minScore,
-        },
-      }),
-      signal: AbortSignal.timeout(5000),
-    });
-    if (!response.ok) return [];
-    const json = await response.json();
-    return json.data?.semanticSearchMemories || [];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Emit a CHAT_TURN event to TES so the conversation-analytics dashboard
- * (Token Universe + Tools tabs) can render. Without this, the dashboard
- * filters on eventType=CHAT_TURN and shows nothing for OpenClaw users
- * because the only events emitted are STORE_MEMORY.
- *
- * Anything missing from the message metadata is omitted rather than
- * defaulted to zero — that way the dashboard can distinguish "no data"
- * from "zero usage".
- */
-async function hostedEmitChatTurn(config, sessionId, turn) {
-  const attributes = {
-    source: "openclaw-plugin",
-    user_message: turn.userMessage,
-    assistant_response: turn.assistantResponse,
-  };
-  if (turn.model) attributes.model = turn.model;
-  if (turn.usage) attributes.usage = turn.usage;
-  if (turn.toolCalls?.length) attributes.tool_calls = turn.toolCalls;
-  if (turn.turnNumber !== undefined) attributes.turn_number = turn.turnNumber;
-  if (turn.systemPrompt) attributes.system_prompt = turn.systemPrompt;
-
-  try {
-    const response = await fetch(`${config.tes_endpoint}/api/graphql`, {
-      method: "POST",
-      headers: tesHeaders(config),
-      // Route through createModuleEvent on the conversation-analytics
-      // module rather than the top-level emitEvent. The latter requires
-      // a permission most client API keys don't have ("Access denied:
-      // You don't have permission to update emitEvent"), but the
-      // module's manifest declares CHAT_TURN as a registered event
-      // type, so the module-scoped path is both authorised and
-      // consistent with how STORE_MEMORY is emitted.
-      body: JSON.stringify({
-        query: `mutation Cme($moduleId: String!, $input: ModuleEventInput!) {
-          createModuleEvent(moduleId: $moduleId, input: $input) { success eventId }
-        }`,
-        variables: {
-          moduleId: "conversation-analytics",
-          input: {
-            eventType: "CHAT_TURN",
-            data: {
-              entity_id: sessionId,
-              attributes,
-            },
-          },
-        },
-      }),
-      signal: AbortSignal.timeout(10000),
-    });
-    if (!response.ok) return null;
-    return response.json();
-  } catch {
-    return null;
-  }
-}
-
-async function hostedStore(config, content, metadata = {}) {
-  try {
-    const response = await fetch(`${config.tes_endpoint}/api/graphql`, {
-      method: "POST",
-      headers: tesHeaders(config),
-      body: JSON.stringify({
-        query: `mutation CreateModuleEvent($moduleId: String!, $input: ModuleEventInput!) {
-          createModuleEvent(moduleId: $moduleId, input: $input) { success eventId }
-        }`,
-        variables: {
-          moduleId: "deep-memory",
-          input: {
-            eventType: "STORE_MEMORY",
-            data: {
-              entity_id: metadata.session_id || "openclaw",
-              attributes: {
-                ...metadata,
-                content,
-                source: "openclaw-plugin",
-              },
-            },
-          },
-        },
-      }),
-      signal: AbortSignal.timeout(10000),
-    });
-    if (!response.ok) return null;
-    return response.json();
-  } catch {
-    return null;
-  }
-}
-
 // --- Hosted context engine ---
 
 // Per-session turn buffer. Holds the user message until the matching
@@ -440,7 +341,7 @@ function createHostedContextEngine(config, opts = {}) {
         const memoryText = results
           .map(
             (m) =>
-              `- [${Math.round((m.similarity || 0) * 100)}%] ${m.content}`
+              `- [${Math.round((m.similarity || 0) * 100)}%] ${sanitizeMemoryContent(m.content)}`
           )
           .join("\n");
 
@@ -638,7 +539,7 @@ Tell the user to run step 1 first, then help them fill in the config with the cr
           return results
             .map(
               (m, i) =>
-                `${i + 1}. [${Math.round((m.similarity || 0) * 100)}%] ${m.content}`
+                `${i + 1}. [${Math.round((m.similarity || 0) * 100)}%] ${sanitizeMemoryContent(m.content)}`
             )
             .join("\n\n");
         },
@@ -705,7 +606,7 @@ Tell the user to run step 1 first, then help them fill in the config with the cr
           return results
             .map(
               (m, i) =>
-                `${i + 1}. [${Math.round((m.similarity || 0) * 100)}%] ${m.content}`
+                `${i + 1}. [${Math.round((m.similarity || 0) * 100)}%] ${sanitizeMemoryContent(m.content)}`
             )
             .join("\n\n");
         },

package/packages/memory/src/sanitize.js

@@ -0,0 +1,61 @@
+/**
+ * Memory-content sanitizer.
+ *
+ * Stored memories from TES often contain dashboard-UI noise (leading
+ * timestamps, layer IDs, confidence/decay metadata, trailing JSON
+ * blobs). This strips them before showing content to the model — the
+ * fact-bearing text is what matters, the metadata just dilutes the
+ * signal and burns context budget.
+ *
+ * Conservative: if stripping would leave no real words, fall back to
+ * the original content. Better a noisy signal than none.
+ *
+ * Canonical implementation. The Claude Code hook (`hooks/scripts/
+ * shared.js`) and the published openclaw-plugin (`openclaw-plugin/
+ * index.js`) each inline the same logic — they're published
+ * standalone and can't cross-import. Update all three if changing.
+ */
+
+const TES_META_FIELDS =
+  "event_id|event_type|entity_type|source|clientId|correlationId|timestamp|session_id|layer_id|confidence|decay_rate|user_id";
+
+export const MEMORY_MAX_LEN = 600;
+
+export function sanitizeMemoryContent(content) {
+  if (typeof content !== "string") return content;
+  let out = content;
+  // Trailing JSON metadata blob (no `m` flag — `$` = end-of-string).
+  out = out.replace(/\n\{\s*\n[\s\S]*?\n\s*\}\s*$/, "");
+  // Inline JSON metadata blobs (2+ consecutive TES metadata fields).
+  out = out.replace(
+    new RegExp(
+      `\\{\\s*\\n(\\s*"(?:${TES_META_FIELDS})"[^\\n]*\\n){2,}\\s*\\}`,
+      "g"
+    ),
+    ""
+  );
+  // Dashboard-UI standalone lines.
+  const linePatterns = [
+    /^\s*anonymous\s*$/gm,
+    /^\s*ml_[a-z0-9_-]+_(episodic|semantic|procedural|working)\s*$/gm,
+    /^\s*\d+%\s*match\s*$/gm,
+    /^\s*Confidence:\s*\d+%\s*$/gm,
+    /^\s*Accessed:\s*\d+x?\s*$/gm,
+    /^\s*<?\s*\d+[smhd]\s*ago\s*$/gm,
+    /^\s*Decay:\s*[\d.]+\s*$/gm,
+    /^\s*Metadata\s*$/gm,
+  ];
+  for (const pat of linePatterns) out = out.replace(pat, "");
+  // Leading ISO timestamps — strip prefix, keep line content.
+  out = out.replace(/^\s*\[\d{4}-\d{2}-\d{2}T[\d:.]+Z\]\s*/gm, "");
+  // Collapse consecutive blank lines.
+  out = out.replace(/\n\s*\n\s*\n+/g, "\n\n").trim();
+  // Cap verbose transcript dumps.
+  if (out.length > MEMORY_MAX_LEN) {
+    out = out.slice(0, MEMORY_MAX_LEN).trimEnd() + "…";
+  }
+  // Fallback to original if we stripped everything meaningful.
+  const wordCount = (out.match(/\b\w{2,}\b/g) || []).length;
+  if (wordCount < 2) return content;
+  return out;
+}

package/packages/memory/src/server.js

@@ -347,7 +347,7 @@ async function main() {
         const health = {
           status: "ok",
           client: CLIENT_ID,
-          version: "0.5.5",
+          version: "0.5.6",
           search: "text",
           db: false,
           ollama: false,