adp-openclaw 0.0.64 → 0.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "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,
@@ -387,8 +388,29 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 envelope: envelopeOptions,
               });
 
+              // Build delivery target for cron jobs
+              // Format: adp-openclaw:{userId} for direct delivery via this channel
+              const cronDeliveryTarget = `adp-openclaw:${userIdentifier}`;
+              const nowMs = Date.now();
+
+              // Build BodyForAgent with context info for cron jobs (like QQBot does)
+              // This tells AI how to set up cron job delivery parameters
+              const contextInfo = `你正在通过 ADP-OpenClaw 与用户对话。
+
+【会话上下文】
+- 用户: ${inMsg.user?.username || inMsg.from} (${userIdentifier})
+- 场景: 私聊
+- 当前时间戳(ms): ${nowMs}
+- 定时提醒投递地址: channel=adp-openclaw, to=${cronDeliveryTarget}`;
+
+              // If message is a command (starts with /), don't inject context
+              const agentBody = inMsg.text.startsWith("/")
+                ? inMsg.text
+                : `${contextInfo}\n\n${inMsg.text}`;
+
               const ctx = runtime.channel.reply.finalizeInboundContext({
                 Body: formattedBody,
+                BodyForAgent: agentBody, // AI sees this context with cron delivery info
                 RawBody: inMsg.text,
                 CommandBody: inMsg.text,
                 // User identity: format as "adp-openclaw:{tenantId}:{userId}" for multi-tenant support
@@ -767,18 +789,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

@@ -482,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
 // ============================================================================