adp-openclaw 0.0.63 → 0.0.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.63",
+  "version": "0.0.65",
   "description": "ADP-OpenClaw demo channel plugin (Go WebSocket backend)",
   "type": "module",
   "dependencies": {

package/src/monitor.ts

@@ -5,6 +5,7 @@ import type { PluginLogger, ClawdbotConfig } from "openclaw/plugin-sdk";
 import { getAdpOpenclawRuntime, setActiveWebSocket } from "./runtime.js";
 import {
   getChatHistory,
+  getMergedChatHistory,
   listSessions,
   resolveSessionKey,
   type ChatHistoryResponse,
@@ -767,18 +768,33 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             try {
               const limit = historyPayload.limit ?? 200;
               
-              // Resolve session key from various inputs
-              let sessionKey = historyPayload.sessionKey || "main";
-              if (!historyPayload.sessionKey && historyPayload.conversationId) {
-                sessionKey = resolveSessionKey(historyPayload.conversationId);
+              let result: ChatHistoryResponse;
+              
+              if (historyPayload.sessionKey) {
+                // If sessionKey is provided directly, use it as-is
+                log?.info(`[adp-openclaw] Using provided sessionKey: ${historyPayload.sessionKey}`);
+                result = await getChatHistory(historyPayload.sessionKey, {
+                  limit,
+                  log,
+                });
+              } else if (historyPayload.conversationId) {
+                // If conversationId is provided, merge old and new session histories
+                // Old format: agent:main:direct:{conversationId}
+                // New format: agent:main:adp-openclaw:direct:{conversationId}
+                log?.info(`[adp-openclaw] Merging old and new session histories for conversationId: ${historyPayload.conversationId}`);
+                result = await getMergedChatHistory(historyPayload.conversationId, {
+                  limit,
+                  log,
+                });
+              } else {
+                // Default to "main" session
+                log?.info(`[adp-openclaw] Using default session: main`);
+                result = await getChatHistory("main", {
+                  limit,
+                  log,
+                });
               }
 
-              // Use CLI backend only
-              const result: ChatHistoryResponse = await getChatHistory(sessionKey, {
-                limit,
-                log,
-              });
-
               log?.info(`[adp-openclaw] Sending conv_response: ${result.messages.length} messages (backend=cli)`);
 
               // Send response back to GoServer

package/src/session-history.ts

@@ -243,8 +243,13 @@ function readSessionTranscript(
         if (parsed.type === "session") {
           continue;
         }
-        // Extract message if present
+        // Extract message if present, skip tool-related roles (toolResult, tool)
         if (parsed.message && parsed.message.role && parsed.message.content) {
+          // Filter out tool-related messages for cleaner display
+          const role = parsed.message.role;
+          if (role === "toolResult" || role === "tool") {
+            continue;
+          }
           const msg: OpenClawMessage = {
             role: parsed.message.role,
             content: extractMessageContent(parsed.message.content),
@@ -477,6 +482,85 @@ export async function getChatHistoryByConversationId(
   return getOpenClawChatHistory(sessionKey, options);
 }
 
+/**
+ * Get merged chat history from both old and new sessionKey formats.
+ * Old format: agent:main:direct:{conversationId}
+ * New format: agent:main:adp-openclaw:direct:{conversationId}
+ * 
+ * This function fetches history from both session keys and merges them by timestamp.
+ * 
+ * @param conversationId - The conversation ID
+ * @param options - Optional parameters
+ * @returns Merged chat history sorted by timestamp
+ */
+export async function getMergedChatHistory(
+  conversationId: string,
+  options?: {
+    limit?: number;
+    log?: PluginLogger;
+  },
+): Promise<ChatHistoryResponse> {
+  const { limit = 200, log } = options ?? {};
+  
+  // Build both old and new session key formats
+  const oldSessionKey = `agent:main:direct:${conversationId}`;
+  const newSessionKey = `agent:main:adp-openclaw:direct:${conversationId}`;
+  
+  log?.info?.(`[session-history] Fetching merged history for conversationId: ${conversationId}`);
+  log?.info?.(`[session-history] Old sessionKey: ${oldSessionKey}`);
+  log?.info?.(`[session-history] New sessionKey: ${newSessionKey}`);
+  
+  // Fetch history from both session keys in parallel
+  const [oldResult, newResult] = await Promise.all([
+    getChatHistory(oldSessionKey, { limit, log }).catch((err) => {
+      log?.debug?.(`[session-history] Failed to fetch old session history: ${err}`);
+      return { sessionKey: oldSessionKey, messages: [], hasMore: false } as ChatHistoryResponse;
+    }),
+    getChatHistory(newSessionKey, { limit, log }).catch((err) => {
+      log?.debug?.(`[session-history] Failed to fetch new session history: ${err}`);
+      return { sessionKey: newSessionKey, messages: [], hasMore: false } as ChatHistoryResponse;
+    }),
+  ]);
+  
+  log?.info?.(`[session-history] Old session messages: ${oldResult.messages.length}`);
+  log?.info?.(`[session-history] New session messages: ${newResult.messages.length}`);
+  
+  // Merge messages from both sessions
+  const allMessages = [...oldResult.messages, ...newResult.messages];
+  
+  // Sort by timestamp (ascending, oldest first)
+  allMessages.sort((a, b) => {
+    const timeA = a.timestamp ?? 0;
+    const timeB = b.timestamp ?? 0;
+    return timeA - timeB;
+  });
+  
+  // Deduplicate by message id (if available) or content+timestamp
+  const seen = new Set<string>();
+  const dedupedMessages = allMessages.filter((msg) => {
+    // Create a unique key for deduplication
+    const key = msg.id || `${msg.role}:${msg.timestamp}:${msg.content.slice(0, 100)}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+  
+  // Apply limit (return last N messages if exceeds limit)
+  const limitedMessages = dedupedMessages.length > limit
+    ? dedupedMessages.slice(-limit)
+    : dedupedMessages;
+  
+  log?.info?.(`[session-history] Merged total: ${limitedMessages.length} messages`);
+  
+  return {
+    sessionKey: newSessionKey, // Return new sessionKey as the primary
+    messages: limitedMessages,
+    hasMore: false,
+  };
+}
+
 // ============================================================================
 // CLI-based Backend
 // ============================================================================