@byte5ai/palaia 2.0.0 → 2.0.2

package/package.json

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

package/src/hooks.ts

@@ -207,6 +207,25 @@ export function extractSlackChannelIdFromSessionKey(sessionKey: string): string
   return undefined;
 }
 
+/**
+ * Extract the real Slack channel ID from event metadata or ctx.
+ * OpenClaw stores the channel in "channel:C0AKE2G15HV" format in:
+ *   - event.metadata.to
+ *   - event.metadata.originatingTo
+ *   - ctx.conversationId
+ *
+ * ctx.channelId is the PROVIDER NAME ("slack"), not the channel ID.
+ * ctx.sessionKey is null during message_received.
+ */
+export function extractChannelIdFromEvent(event: any, ctx: any): string | undefined {
+  const rawTo = event?.metadata?.to
+    ?? event?.metadata?.originatingTo
+    ?? ctx?.conversationId
+    ?? "";
+  const match = String(rawTo).match(/^(?:channel|dm|group):([A-Z0-9]+)$/i);
+  return match ? match[1].toUpperCase() : undefined;
+}
+
 /**
  * Resolve the session key for the current turn from available ctx.
  * Tries ctx.sessionKey first, then falls back to sessionId.
@@ -713,21 +732,38 @@ function buildExtractionPrompt(projects: CachedProject[]): string {
   return `${EXTRACTION_SYSTEM_PROMPT_BASE}\n\nKnown projects: ${projectList}`;
 }
 
-const CHEAP_MODELS: Record<string, string> = {
-  anthropic: "claude-haiku-4",
-  openai: "gpt-4.1-mini",
-  google: "gemini-2.0-flash",
-};
+/** Whether the captureModel fallback warning has already been logged (to avoid spam). */
+let _captureModelFallbackWarned = false;
+
+/** Whether the captureModel→primary model fallback warning has been logged (max 1x per gateway lifetime). */
+let _captureModelFailoverWarned = false;
 
+/** Reset captureModel fallback warning flag (for testing). */
+export function resetCaptureModelFallbackWarning(): void {
+  _captureModelFallbackWarned = false;
+  _captureModelFailoverWarned = false;
+}
+
+/**
+ * Resolve the model to use for LLM-based capture extraction.
+ *
+ * Strategy (no static model mapping — user config is the source of truth):
+ * 1. If captureModel is set explicitly (e.g. "anthropic/claude-haiku-4-5"): use it directly.
+ * 2. If captureModel is unset: use the primary model from user config.
+ *    Log a one-time warning recommending to set a cheaper captureModel.
+ * 3. Never fall back to static model IDs — model IDs change and not every user has Anthropic.
+ */
 export function resolveCaptureModel(
   config: any,
   captureModel?: string,
 ): { provider: string; model: string } | undefined {
+  // Case 1: explicit model ID provided (not "cheap")
   if (captureModel && captureModel !== "cheap") {
     const parts = captureModel.split("/");
     if (parts.length >= 2) {
       return { provider: parts[0], model: parts.slice(1).join("/") };
     }
+    // No slash — treat as model name with provider from primary config
     const defaultsModel = config?.agents?.defaults?.model;
     const primary = typeof defaultsModel === "string"
       ? defaultsModel.trim()
@@ -738,19 +774,24 @@ export function resolveCaptureModel(
     }
   }
 
+  // Case 2: "cheap" or unset — use primary model from user config
   const defaultsModel = config?.agents?.defaults?.model;
+
   const primary = typeof defaultsModel === "string"
     ? defaultsModel.trim()
-    : (defaultsModel?.primary?.trim() ?? "");
-  const defaultProvider = primary.split("/")[0];
-  const defaultModel = primary.split("/").slice(1).join("/");
-
-  if (defaultProvider && CHEAP_MODELS[defaultProvider]) {
-    return { provider: defaultProvider, model: CHEAP_MODELS[defaultProvider] };
-  }
+    : (typeof defaultsModel === "object" && defaultsModel !== null
+      ? String(defaultsModel.primary ?? "").trim()
+      : "");
 
-  if (defaultProvider && defaultModel) {
-    return { provider: defaultProvider, model: defaultModel };
+  if (primary) {
+    const parts = primary.split("/");
+    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.`);
+      }
+      return { provider: parts[0], model: parts.slice(1).join("/") };
+    }
   }
 
   return undefined;
@@ -771,6 +812,52 @@ function collectText(payloads: Array<{ text?: string; isError?: boolean }> | und
     .trim();
 }
 
+/**
+ * Trim message texts to a recent window for LLM extraction.
+ * Only extract from recent exchanges — full history causes LLM timeouts
+ * and dilutes extraction quality.
+ *
+ * Strategy: keep last N user+assistant pairs (skip toolResult roles),
+ * then hard-cap at maxChars from the end (newest messages kept).
+ */
+export function trimToRecentExchanges(
+  texts: Array<{ role: string; text: string }>,
+  maxPairs = 5,
+  maxChars = 10_000,
+): Array<{ role: string; text: 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)
+  // 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") {
+      pairCount++;
+      if (pairCount > maxPairs) {
+        cutIndex = i + 1; // keep from next message onwards
+        break;
+      }
+    }
+    if (exchanges[i].role !== lastRole) {
+      lastRole = exchanges[i].role;
+    }
+  }
+  let trimmed = exchanges.slice(cutIndex);
+
+  // Hard cap: max chars from the end (keep newest)
+  let totalChars = trimmed.reduce((sum, t) => sum + t.text.length + t.role.length + 5, 0);
+  while (totalChars > maxChars && trimmed.length > 1) {
+    const removed = trimmed.shift()!;
+    totalChars -= removed.text.length + removed.role.length + 5;
+  }
+
+  return trimmed;
+}
+
 export async function extractWithLLM(
   messages: unknown[],
   config: any,
@@ -784,9 +871,11 @@ export async function extractWithLLM(
     throw new Error("No model available for LLM extraction");
   }
 
-  const texts = extractMessageTexts(messages);
-  const exchangeText = texts
-    .filter((t) => t.role === "user" || t.role === "assistant")
+  const allTexts = extractMessageTexts(messages);
+  // Only extract from recent exchanges — full history causes LLM timeouts
+  // and dilutes extraction quality
+  const recentTexts = trimToRecentExchanges(allTexts);
+  const exchangeText = recentTexts
     .map((t) => `[${t.role}]: ${t.text}`)
     .join("\n");
 
@@ -1212,14 +1301,32 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
     try {
       const messageId = event?.metadata?.messageId;
       const provider = event?.metadata?.provider;
-      const channelId = ctx?.channelId;
+
+      // ctx.channelId returns the provider name ("slack"), NOT the actual channel ID.
+      // ctx.sessionKey is null during message_received.
+      // Extract the real channel ID from event.metadata.to / ctx.conversationId.
+      const channelId = extractChannelIdFromEvent(event, ctx)
+        ?? (resolveSessionKeyFromCtx(ctx) ? extractSlackChannelIdFromSessionKey(resolveSessionKeyFromCtx(ctx)!) : undefined);
+      const sessionKey = resolveSessionKeyFromCtx(ctx);
+
 
       if (messageId && channelId && provider && REACTION_SUPPORTED_PROVIDERS.has(provider)) {
-        lastInboundMessageByChannel.set(channelId, {
+        // Normalize channelId to UPPERCASE for consistent lookups
+        // (extractSlackChannelIdFromSessionKey returns uppercase)
+        const normalizedChannelId = String(channelId).toUpperCase();
+        lastInboundMessageByChannel.set(normalizedChannelId, {
           messageId: String(messageId),
           provider,
           timestamp: Date.now(),
         });
+
+        // Also populate turnState if sessionKey is available
+        if (sessionKey) {
+          const turnState = getOrCreateTurnState(sessionKey);
+          turnState.lastInboundMessageId = String(messageId);
+          turnState.lastInboundChannelId = normalizedChannelId;
+          turnState.channelProvider = provider;
+        }
       }
     } catch {
       // Non-fatal — never block message flow
@@ -1314,10 +1421,11 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           const turnState = getOrCreateTurnState(sessionKey);
           turnState.recallOccurred = true;
 
-          // Populate channel info from sessionKey for reaction routing
+          // Populate channel info — prefer event metadata, fall back to sessionKey
           const provider = extractChannelFromSessionKey(sessionKey);
           if (provider) turnState.channelProvider = provider;
-          const slackChannel = extractSlackChannelIdFromSessionKey(sessionKey);
+          const slackChannel = extractChannelIdFromEvent(event, ctx)
+            ?? extractSlackChannelIdFromSessionKey(sessionKey);
           if (slackChannel) turnState.lastInboundChannelId = slackChannel;
 
           // Try to get the inbound message ID from the message_received store
@@ -1356,20 +1464,24 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
   // ── agent_end (Issue #64 + #81: Auto-Capture with Metadata + Reactions) ───
   if (config.autoCapture) {
     api.on("agent_end", async (event: any, ctx: any) => {
+      // Resolve session key for turn state
+      const sessionKey = resolveSessionKeyFromCtx(ctx);
+
+      // DEBUG: always log agent_end firing
+
       if (!event.success || !event.messages || event.messages.length === 0) {
         return;
       }
 
-      // Resolve session key for turn state
-      const sessionKey = resolveSessionKeyFromCtx(ctx);
-
       try {
         const agentName = process.env.PALAIA_AGENT || undefined;
 
         const allTexts = extractMessageTexts(event.messages);
 
         const userTurns = allTexts.filter((t) => t.role === "user").length;
-        if (userTurns < config.captureMinTurns) return;
+        if (userTurns < config.captureMinTurns) {
+          return;
+        }
 
         // Parse capture hints from all messages (Issue #81)
         const collectedHints: PalaiaHint[] = [];
@@ -1378,17 +1490,21 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           collectedHints.push(...hints);
         }
 
-        // Build exchange text
+        // Only extract from recent exchanges — full history causes LLM timeouts
+        // and dilutes extraction quality
+        const recentTexts = trimToRecentExchanges(allTexts);
+
+        // Build exchange text from recent window only
         const exchangeParts: string[] = [];
-        for (const t of allTexts) {
-          if (t.role === "user" || t.role === "assistant") {
-            const { cleanedText } = parsePalaiaHints(t.text);
-            exchangeParts.push(`[${t.role}]: ${cleanedText}`);
-          }
+        for (const t of recentTexts) {
+          const { cleanedText } = parsePalaiaHints(t.text);
+          exchangeParts.push(`[${t.role}]: ${cleanedText}`);
         }
         const exchangeText = exchangeParts.join("\n");
 
-        if (!shouldAttemptCapture(exchangeText)) return;
+        if (!shouldAttemptCapture(exchangeText)) {
+          return;
+        }
 
         const knownProjects = await loadProjects(opts);
 
@@ -1422,13 +1538,8 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           return args;
         };
 
-        // LLM-based extraction (primary)
-        let llmHandled = false;
-        try {
-          const results = await extractWithLLM(event.messages, api.config, {
-            captureModel: config.captureModel,
-          }, knownProjects);
-
+        // Helper: store LLM extraction results
+        const storeLLMResults = async (results: ExtractionResult[]) => {
           for (const r of results) {
             if (r.significance >= config.captureMinSignificance) {
               const hintForProject = collectedHints.find((h) => h.project);
@@ -1450,12 +1561,46 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
               );
             }
           }
+        };
+
+        // LLM-based extraction (primary)
+        let llmHandled = false;
+        try {
+          const results = await extractWithLLM(event.messages, api.config, {
+            captureModel: config.captureModel,
+          }, knownProjects);
 
+          await storeLLMResults(results);
           llmHandled = true;
         } catch (llmError) {
-          if (!_llmImportFailureLogged) {
-            console.warn(`[palaia] LLM extraction failed, using rule-based fallback: ${llmError}`);
-            _llmImportFailureLogged = true;
+          // Check if this is a model-availability error (not a generic import failure)
+          const errStr = String(llmError);
+          const isModelError = /FailoverError|Unknown model|unknown model|401|403|model.*not found|not_found|model_not_found/i.test(errStr);
+
+          if (isModelError && config.captureModel) {
+            // 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.`);
+            }
+            try {
+              // Retry without captureModel → resolveCaptureModel will use primary model
+              const fallbackResults = await extractWithLLM(event.messages, api.config, {
+                captureModel: undefined,
+              }, knownProjects);
+              await storeLLMResults(fallbackResults);
+              llmHandled = true;
+            } catch (fallbackError) {
+              if (!_llmImportFailureLogged) {
+                console.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}`);
+              _llmImportFailureLogged = true;
+            }
           }
         }
 
@@ -1465,7 +1610,9 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
 
           if (config.captureFrequency === "significant") {
             const significance = extractSignificance(exchangeText);
-            if (!significance) return;
+            if (!significance) {
+              return;
+            }
             captureData = significance;
           } else {
             const summary = exchangeParts
@@ -1497,6 +1644,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
         if (sessionKey) {
           const turnState = getOrCreateTurnState(sessionKey);
           turnState.capturedInThisTurn = true;
+        } else {
         }
       } catch (error) {
         console.warn(`[palaia] Auto-capture failed: ${error}`);
@@ -1512,9 +1660,11 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
               || extractChannelFromSessionKey(sessionKey)
               || (ctx?.channelId as string | undefined);
             const channelId = turnState.lastInboundChannelId
+              || extractChannelIdFromEvent(event, ctx)
               || extractSlackChannelIdFromSessionKey(sessionKey);
             const messageId = turnState.lastInboundMessageId;
 
+
             if (provider && REACTION_SUPPORTED_PROVIDERS.has(provider) && channelId && messageId) {
               // Capture confirmation: 💾
               if (turnState.capturedInThisTurn && config.showCaptureConfirm) {
@@ -1525,6 +1675,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
               if (turnState.recallOccurred && config.showMemorySources) {
                 await sendReaction(channelId, messageId, "brain", provider);
               }
+            } else {
             }
           }
         } catch (reactionError) {
@@ -1549,6 +1700,7 @@ export function registerHooks(api: any, config: PalaiaPluginConfig): void {
           const provider = turnState.channelProvider
             || extractChannelFromSessionKey(sessionKey);
           const channelId = turnState.lastInboundChannelId
+            || extractChannelIdFromEvent(_event, ctx)
             || extractSlackChannelIdFromSessionKey(sessionKey);
           const messageId = turnState.lastInboundMessageId;