@byte5ai/palaia 2.0.4 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byte5ai/palaia",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Palaia memory backend for OpenClaw",
   "main": "index.ts",
   "openclaw": {

package/src/hooks.ts

@@ -137,6 +137,16 @@ const lastInboundMessageByChannel = new Map<string, { messageId: string; provide
 /** Channels that support emoji reactions. */
 const REACTION_SUPPORTED_PROVIDERS = new Set(["slack", "discord"]);
 
+// ============================================================================
+// Logger (Issue: api.logger integration)
+// ============================================================================
+
+/** Module-level logger — defaults to console, replaced by api.logger in registerHooks. */
+let logger: { info: (...args: any[]) => void; warn: (...args: any[]) => void } = {
+  info: (...args: any[]) => console.log(...args),
+  warn: (...args: any[]) => console.warn(...args),
+};
+
 // ============================================================================
 // Scope Validation (Issue #90)
 // ============================================================================
@@ -350,7 +360,7 @@ async function sendSlackReaction(
 ): Promise<void> {
   const token = await resolveSlackBotToken();
   if (!token) {
-    console.warn("[palaia] Cannot send Slack reaction: no bot token found");
+    logger.warn("[palaia] Cannot send Slack reaction: no bot token found");
     return;
   }
 
@@ -375,11 +385,11 @@ async function sendSlackReaction(
     });
     const data = await response.json() as { ok: boolean; error?: string };
     if (!data.ok && data.error !== "already_reacted") {
-      console.warn(`[palaia] Slack reaction failed: ${data.error} (${normalizedEmoji} on ${channelId})`);
+      logger.warn(`[palaia] Slack reaction failed: ${data.error} (${normalizedEmoji} on ${channelId})`);
     }
   } catch (err) {
     if ((err as Error).name !== "AbortError") {
-      console.warn(`[palaia] Slack reaction error (${normalizedEmoji}): ${err}`);
+      logger.warn(`[palaia] Slack reaction error (${normalizedEmoji}): ${err}`);
     }
   } finally {
     clearTimeout(timeout);
@@ -792,7 +802,7 @@ export function resolveCaptureModel(
     if (parts.length >= 2) {
       if (!_captureModelFallbackWarned) {
         _captureModelFallbackWarned = true;
-        console.warn(`[palaia] No captureModel configured — using primary model. Set captureModel in plugin config for cost savings.`);
+        logger.warn(`[palaia] No captureModel configured — using primary model. Set captureModel in plugin config for cost savings.`);
       }
       return { provider: parts[0], model: parts.slice(1).join("/") };
     }
@@ -825,21 +835,27 @@ function collectText(payloads: Array<{ text?: string; isError?: boolean }> | und
  * then hard-cap at maxChars from the end (newest messages kept).
  */
 export function trimToRecentExchanges(
-  texts: Array<{ role: string; text: string }>,
+  texts: Array<{ role: string; text: string; provenance?: string }>,
   maxPairs = 5,
   maxChars = 10_000,
-): Array<{ role: string; text: string }> {
+): Array<{ role: string; text: string; provenance?: string }> {
   // Filter to only user + assistant messages (skip tool, toolResult, system, etc.)
   const exchanges = texts.filter((t) => t.role === "user" || t.role === "assistant");
 
   // Keep the last N pairs (a pair = one user + one assistant message)
+  // Only count external_user messages as real user turns.
+  // System-injected user messages (inter_session, internal_system) don't count as conversation turns.
   // Walk backwards, count pairs
   let pairCount = 0;
   let lastRole = "";
   let cutIndex = 0; // default: keep everything
   for (let i = exchanges.length - 1; i >= 0; i--) {
-    // Count a new pair when we see a user message after having seen an assistant
-    if (exchanges[i].role === "user" && lastRole === "assistant") {
+    const isRealUser = exchanges[i].role === "user" && (
+      exchanges[i].provenance === "external_user" ||
+      !exchanges[i].provenance // backward compat: no provenance = treat as real user
+    );
+    // Count a new pair when we see a real user message after having seen an assistant
+    if (isRealUser && lastRole === "assistant") {
       pairCount++;
       if (pairCount > maxPairs) {
         cutIndex = i + 1; // keep from next message onwards
@@ -1087,8 +1103,8 @@ export function extractSignificance(
   return { tags, type: primaryType, summary };
 }
 
-export function extractMessageTexts(messages: unknown[]): Array<{ role: string; text: string }> {
-  const result: Array<{ role: string; text: string }> = [];
+export function extractMessageTexts(messages: unknown[]): Array<{ role: string; text: string; provenance?: string }> {
+  const result: Array<{ role: string; text: string; provenance?: string }> = [];
 
   for (const msg of messages) {
     if (!msg || typeof msg !== "object") continue;
@@ -1096,8 +1112,12 @@ export function extractMessageTexts(messages: unknown[]): Array<{ role: string;
     const role = m.role;
     if (!role || typeof role !== "string") continue;
 
+    // Extract provenance kind (string or object with .kind)
+    const rawProvenance = (m as any).provenance?.kind ?? (m as any).provenance;
+    const provenance = typeof rawProvenance === "string" ? rawProvenance : undefined;
+
     if (typeof m.content === "string" && m.content.trim()) {
-      result.push({ role, text: m.content.trim() });
+      result.push({ role, text: m.content.trim(), provenance });
       continue;
     }
 
@@ -1110,7 +1130,7 @@ export function extractMessageTexts(messages: unknown[]): Array<{ role: string;
           typeof block.text === "string" &&
           block.text.trim()
         ) {
-          result.push({ role, text: block.text.trim() });
+          result.push({ role, text: block.text.trim(), provenance });
         }
       }
     }
@@ -1121,6 +1141,12 @@ export function extractMessageTexts(messages: unknown[]): Array<{ role: string;
 
 export function getLastUserMessage(messages: unknown[]): string | null {
   const texts = extractMessageTexts(messages);
+  // Prefer external_user provenance (real human input)
+  for (let i = texts.length - 1; i >= 0; i--) {
+    if (texts[i].role === "user" && texts[i].provenance === "external_user")
+      return texts[i].text;
+  }
+  // Fallback: any user message (backward compat for OpenClaw without provenance)
   for (let i = texts.length - 1; i >= 0; i--) {
     if (texts[i].role === "user") return texts[i].text;
   }
@@ -1128,80 +1154,122 @@ export function getLastUserMessage(messages: unknown[]): string | null {
 }
 
 // ============================================================================
-// Recall Query Builder (Issue #65 upgrade: robust user message extraction)
+// Channel Envelope Stripping (v2.0.6)
 // ============================================================================
 
-/** Day-of-week prefixes used as system markers in messages. */
-const DAY_PREFIXES = ["[Mon ", "[Tue ", "[Wed ", "[Thu ", "[Fri ", "[Sat ", "[Sun "];
+/**
+ * Strip OpenClaw channel envelope from message text.
+ * Matches the pattern: [TIMESTAMP] or [CHANNEL TIMESTAMP] prefix
+ * that OpenClaw adds to inbound messages from all channels.
+ * Based on OpenClaw's internal stripEnvelope() logic.
+ */
+const ENVELOPE_PREFIX_RE = /^\[([^\]]+)\]\s*/;
+const ENVELOPE_CHANNELS = [
+  "WebChat", "WhatsApp", "Telegram", "Signal", "Slack",
+  "Discord", "Google Chat", "iMessage", "Teams", "Matrix",
+  "Zalo", "Zalo Personal", "BlueBubbles",
+];
+
+function looksLikeEnvelopeHeader(header: string): boolean {
+  // ISO timestamp pattern
+  if (/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z\b/.test(header)) return true;
+  // Space-separated timestamp
+  if (/\d{4}-\d{2}-\d{2} \d{2}:\d{2}\b/.test(header)) return true;
+  // Channel prefix
+  return ENVELOPE_CHANNELS.some(ch => header.startsWith(`${ch} `));
+}
+
+export function stripChannelEnvelope(text: string): string {
+  const match = text.match(ENVELOPE_PREFIX_RE);
+  if (!match) return text;
+  if (!looksLikeEnvelopeHeader(match[1] ?? "")) return text;
+  return text.slice(match[0].length);
+}
 
 /**
- * Clean a raw message string by removing system markers, JSON blocks,
- * and other noise that degrades semantic search quality.
+ * Strip "System: [timestamp] Channel message in #channel from User: " prefix.
+ * OpenClaw wraps inbound messages with this pattern for all channel providers.
  */
-export function cleanMessageForQuery(text: string): string {
-  let cleaned = text;
-
-  // Remove JSON code blocks (```json ... ```)
-  cleaned = cleaned.replace(/```json[\s\S]*?```/gi, "");
-
-  // Remove lines starting with system markers
-  cleaned = cleaned
-    .split("\n")
-    .filter((line) => {
-      const trimmed = line.trimStart();
-      if (trimmed.startsWith("System:")) return false;
-      if (trimmed.startsWith("[Queued")) return false;
-      if (trimmed.startsWith("[Inter-session")) return false;
-      for (const prefix of DAY_PREFIXES) {
-        if (trimmed.startsWith(prefix)) return false;
-      }
-      return true;
-    })
-    .join("\n")
-    .trim();
+const SYSTEM_PREFIX_RE = /^System:\s*\[\d{4}-\d{2}-\d{2}[^\]]*\]\s*(?:Slack message|Telegram message|Discord message|WhatsApp message|Signal message|message).*?(?:from \w+:\s*)?/i;
 
-  return cleaned;
+export function stripSystemPrefix(text: string): string {
+  const match = text.match(SYSTEM_PREFIX_RE);
+  if (match) return text.slice(match[0].length);
+  return text;
+}
+
+// ============================================================================
+// Recall Query Builder (v2.0.6: envelope-aware, provenance-based)
+// ============================================================================
+
+/**
+ * Messages that are purely system content (no user text).
+ * Used to skip edited notifications, sync events, inter-session messages, etc.
+ */
+function isSystemOnlyContent(text: string): boolean {
+  if (!text) return true;
+  if (text.startsWith("System:")) return true;
+  if (text.startsWith("[Queued")) return true;
+  if (text.startsWith("[Inter-session")) return true;
+  if (/^Slack message (edited|deleted)/.test(text)) return true;
+  if (/^\[auto\]/.test(text)) return true;
+  if (text.length < 3) return true;
+  return false;
 }
 
 /**
  * Build a recall query from message history.
  *
- * - Always uses actual user messages (ignores event.prompt which may be stale/synthetic).
- * - If the last user message is short (< 30 chars), prepends the previous user message
- *   for better semantic context ("Ja", "OK", "Status" alone are poor queries).
- * - Strips system markers, JSON blocks, and other noise.
- * - Hard-caps at 500 characters.
+ * v2.0.6: Strips OpenClaw channel envelopes (System: [...] Slack message from ...:)
+ * and inter-session prefixes before building the query. This prevents envelope
+ * metadata from polluting semantic search and causing timeouts / false-high scores.
  *
- * Returns empty string if nothing usable remains.
+ * - Filters out inter_session and internal_system provenance messages.
+ * - Falls back to any user message for backward compat (OpenClaw without provenance).
+ * - Strips channel envelopes and system prefixes from message text.
+ * - Skips system-only content (edited notifications, sync events).
+ * - Short messages (< 30 chars): prepends previous for context.
+ * - Hard-caps at 500 characters.
  */
 export function buildRecallQuery(messages: unknown[]): string {
   const texts = extractMessageTexts(messages);
-  const userMessages: string[] = [];
-  for (let i = texts.length - 1; i >= 0 && userMessages.length < 2; i--) {
-    if (texts[i].role === "user") {
-      const cleaned = cleanMessageForQuery(texts[i].text);
-      if (cleaned) userMessages.unshift(cleaned);
-    }
-  }
 
-  if (userMessages.length === 0) return "";
+  // Step 1: Filter out inter_session messages (sub-agent results, sessions_send)
+  const candidates = texts.filter(
+    t => t.role === "user" && t.provenance !== "inter_session" && t.provenance !== "internal_system"
+  );
+
+  // Fallback: if no messages without provenance, use all user messages
+  const userMsgs = candidates.length > 0
+    ? candidates
+    : texts.filter(t => t.role === "user");
 
-  const lastMsg = userMessages[userMessages.length - 1];
+  if (userMsgs.length === 0) return "";
 
-  // If the last user message is very short, include previous for context
-  let query: string;
-  if (lastMsg.length < 30 && userMessages.length > 1) {
-    query = `${userMessages[userMessages.length - 2]} ${lastMsg}`;
-  } else {
-    query = lastMsg;
+  // Step 2: Strip envelopes from the last user message(s)
+  let lastText = stripSystemPrefix(stripChannelEnvelope(userMsgs[userMsgs.length - 1].text.trim()));
+
+  // Skip system-only messages (edited notifications, sync events, etc.)
+  // Walk backwards to find a message with actual content
+  let idx = userMsgs.length - 1;
+  while (idx >= 0 && (!lastText || isSystemOnlyContent(lastText))) {
+    idx--;
+    if (idx >= 0) {
+      lastText = stripSystemPrefix(stripChannelEnvelope(userMsgs[idx].text.trim()));
+    }
   }
 
-  // Hard cap at 500 characters
-  if (query.length > 500) {
-    query = query.slice(0, 500);
+  if (!lastText) return "";
+
+  // Step 3: Short messages → include previous for context
+  if (lastText.length < 30 && idx > 0) {
+    const prevText = stripSystemPrefix(stripChannelEnvelope(userMsgs[idx - 1].text.trim()));
+    if (prevText && !isSystemOnlyContent(prevText)) {
+      return `${prevText} ${lastText}`.slice(0, 500);
+    }
   }
 
-  return query.trim();
+  return lastText.slice(0, 500);
 }
 
 // ============================================================================
@@ -1304,22 +1372,27 @@ export function resetTurnState(): void {
  * Register lifecycle hooks on the plugin API.
  */
 export function registerHooks(api: any, config: PalaiaPluginConfig): void {
+  // Store api.logger for module-wide use (integrates into OpenClaw log system)
+  if (api.logger && typeof api.logger.info === "function") {
+    logger = api.logger;
+  }
+
   const opts = buildRunnerOpts(config);
 
-  // ── Startup checks (H-2, H-3) ─────────────────────────────────
+  // ── Startup checks (H-2, H-3, captureModel validation) ────────
   (async () => {
     // H-2: Warn if no agent is configured
     if (!process.env.PALAIA_AGENT) {
       try {
         const statusOut = await run(["config", "get", "agent"], { ...opts, timeoutMs: 3000 });
         if (!statusOut.trim()) {
-          console.warn(
+          logger.warn(
             "[palaia] No agent configured. Set PALAIA_AGENT env var or run 'palaia init --agent <name>'. " +
             "Auto-captured entries will have no agent attribution."
           );
         }
       } catch {
-        console.warn(
+        logger.warn(
           "[palaia] No agent configured. Set PALAIA_AGENT env var or run 'palaia init --agent <name>'. " +
           "Auto-captured entries will have no agent attribution."
         );
@@ -1346,7 +1419,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           || status.config?.embedding_provider
         );
         if (!hasSemanticProvider && !hasProviderConfig) {
-          console.warn(
+          logger.warn(
             "[palaia] No embedding provider configured. Semantic search is inactive (BM25 keyword-only). " +
             "Run 'pip install palaia[fastembed]' and 'palaia doctor --fix' for better recall quality."
           );
@@ -1356,6 +1429,19 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
     } catch {
       // Non-fatal — status check failed, skip warning (avoid false positive)
     }
+
+    // Validate captureModel auth at plugin startup via modelAuth API
+    if (config.captureModel && api.runtime?.modelAuth) {
+      try {
+        const resolved = resolveCaptureModel(api.config, config.captureModel);
+        if (resolved?.provider) {
+          const key = await api.runtime.modelAuth.resolveApiKeyForProvider({ provider: resolved.provider, cfg: api.config });
+          if (!key) {
+            logger.warn(`[palaia] captureModel provider "${resolved.provider}" has no API key — auto-capture LLM extraction will fail`);
+          }
+        }
+      } catch { /* non-fatal */ }
+    }
   })();
 
   // ── /palaia status command ─────────────────────────────────────
@@ -1445,7 +1531,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
                 entries = result.results;
               }
             } catch (queryError) {
-              console.warn(`[palaia] Query recall failed, falling back to list: ${queryError}`);
+              logger.warn(`[palaia] Query recall failed, falling back to list: ${queryError}`);
             }
           }
         }
@@ -1556,7 +1642,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             : undefined,
         };
       } catch (error) {
-        console.warn(`[palaia] Memory injection failed: ${error}`);
+        logger.warn(`[palaia] Memory injection failed: ${error}`);
       }
     });
   }
@@ -1669,7 +1755,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
                   (p) => p.name.toLowerCase() === validatedProject!.toLowerCase(),
                 );
                 if (!isKnown) {
-                  console.log(`[palaia] Auto-capture: unknown project "${validatedProject}" ignored`);
+                  logger.info(`[palaia] Auto-capture: unknown project "${validatedProject}" ignored`);
                   validatedProject = null;
                 }
               }
@@ -1686,7 +1772,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
                 effectiveScope,
               );
               await run(args, { ...opts, timeoutMs: 10_000 });
-              console.log(
+              logger.info(
                 `[palaia] LLM auto-captured: type=${r.type}, significance=${r.significance}, tags=${tags.join(",")}, project=${validatedProject || "none"}, scope=${effectiveScope || "team"}`
               );
             }
@@ -1711,7 +1797,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             // captureModel is broken — try primary model as fallback
             if (!_captureModelFailoverWarned) {
               _captureModelFailoverWarned = true;
-              console.warn(`[palaia] WARNING: captureModel failed (${errStr}). Using primary model as fallback. Please update captureModel in your config.`);
+              logger.warn(`[palaia] WARNING: captureModel failed (${errStr}). Using primary model as fallback. Please update captureModel in your config.`);
             }
             try {
               // Retry without captureModel → resolveCaptureModel will use primary model
@@ -1722,13 +1808,13 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
               llmHandled = true;
             } catch (fallbackError) {
               if (!_llmImportFailureLogged) {
-                console.warn(`[palaia] LLM extraction failed (primary model fallback also failed): ${fallbackError}`);
+                logger.warn(`[palaia] LLM extraction failed (primary model fallback also failed): ${fallbackError}`);
                 _llmImportFailureLogged = true;
               }
             }
           } else {
             if (!_llmImportFailureLogged) {
-              console.warn(`[palaia] LLM extraction failed, using rule-based fallback: ${llmError}`);
+              logger.warn(`[palaia] LLM extraction failed, using rule-based fallback: ${llmError}`);
               _llmImportFailureLogged = true;
             }
           }
@@ -1770,7 +1856,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           );
 
           await run(args, { ...opts, timeoutMs: 10_000 });
-          console.log(
+          logger.info(
             `[palaia] Rule-based auto-captured: type=${captureData.type}, tags=${captureData.tags.join(",")}`
           );
         }
@@ -1782,7 +1868,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
         } else {
         }
       } catch (error) {
-        console.warn(`[palaia] Auto-capture failed: ${error}`);
+        logger.warn(`[palaia] Auto-capture failed: ${error}`);
       }
 
       // ── Emoji Reactions (Issue #87) ──────────────────────────
@@ -1814,7 +1900,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
             }
           }
         } catch (reactionError) {
-          console.warn(`[palaia] Reaction sending failed: ${reactionError}`);
+          logger.warn(`[palaia] Reaction sending failed: ${reactionError}`);
         } finally {
           // Always clean up turn state
           deleteTurnState(sessionKey);
@@ -1844,7 +1930,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           }
         }
       } catch (err) {
-        console.warn(`[palaia] Recall reaction failed: ${err}`);
+        logger.warn(`[palaia] Recall reaction failed: ${err}`);
       } finally {
         deleteTurnState(sessionKey);
       }
@@ -1857,10 +1943,10 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
     start: async () => {
       const result = await recover(opts);
       if (result.replayed > 0) {
-        console.log(`[palaia] WAL recovery: replayed ${result.replayed} entries`);
+        logger.info(`[palaia] WAL recovery: replayed ${result.replayed} entries`);
       }
       if (result.errors > 0) {
-        console.warn(`[palaia] WAL recovery completed with ${result.errors} error(s)`);
+        logger.warn(`[palaia] WAL recovery completed with ${result.errors} error(s)`);
       }
     },
   });