adp-openclaw 0.0.55 → 0.0.57

package/package.json

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

package/src/monitor.ts

@@ -23,6 +23,8 @@ import {
   formatUploadResultAsMarkdown,
 } from "./tool-result-message-blocks.js";
 import crypto from "crypto";
+import fs from "fs";
+import path from "path";
 // @ts-ignore - import JSON file
 import packageJson from "../package.json" with { type: "json" };
 
@@ -116,6 +118,167 @@ function generateRequestId(): string {
   return `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
+/**
+ * Mark a session's abortedLastRun flag in the sessions store.
+ * This tells the SDK to inject an "abort hint" on the next message,
+ * preventing the AI from resuming the cancelled task.
+ */
+async function markSessionAborted(params: {
+  sessionKey: string;
+  runtime: ReturnType<typeof getAdpOpenclawRuntime>;
+  cfg?: ClawdbotConfig;
+  log?: PluginLogger;
+}): Promise<void> {
+  const { sessionKey, runtime, cfg, log } = params;
+  try {
+    // Use SDK's resolveStorePath to find the sessions.json location
+    const storePath = runtime.channel.session.resolveStorePath(cfg?.session?.store);
+    if (!storePath || !fs.existsSync(storePath)) {
+      log?.warn?.(`[adp-openclaw] Cannot mark session aborted: store not found at ${storePath}`);
+      return;
+    }
+
+    const raw = fs.readFileSync(storePath, "utf-8");
+    const store = JSON.parse(raw) as Record<string, { abortedLastRun?: boolean; updatedAt?: number; [key: string]: unknown }>;
+
+    // Try both the raw sessionKey and the "agent:main:{sessionKey}" variant
+    const candidates = [sessionKey, `agent:main:${sessionKey}`];
+    let matchedKey: string | undefined;
+    for (const key of candidates) {
+      if (store[key]) {
+        matchedKey = key;
+        break;
+      }
+    }
+
+    if (!matchedKey) {
+      log?.info?.(`[adp-openclaw] Session key not found in store for abort marking: ${sessionKey}`);
+      return;
+    }
+
+    store[matchedKey].abortedLastRun = true;
+    store[matchedKey].updatedAt = Date.now();
+    fs.writeFileSync(storePath, JSON.stringify(store, null, 2), "utf-8");
+    log?.info?.(`[adp-openclaw] Marked session ${matchedKey} as abortedLastRun=true`);
+  } catch (err) {
+    log?.error?.(`[adp-openclaw] Failed to mark session aborted: ${err}`);
+  }
+}
+
+/**
+ * After an abort, trim the aborted user message and any partial assistant reply
+ * from the JSONL transcript file. This prevents the AI from seeing the cancelled
+ * request in its context window and resuming it on the next turn.
+ *
+ * The JSONL transcript is a tree structure (id + parentId). We find the last
+ * user message entry and remove it (plus any subsequent entries like partial
+ * assistant replies). This is equivalent to SessionManager.branch(parentId).
+ */
+async function trimAbortedMessagesFromTranscript(params: {
+  sessionKey: string;
+  runtime: ReturnType<typeof getAdpOpenclawRuntime>;
+  cfg?: ClawdbotConfig;
+  log?: PluginLogger;
+}): Promise<void> {
+  const { sessionKey, runtime, cfg, log } = params;
+  try {
+    const storePath = runtime.channel.session.resolveStorePath(cfg?.session?.store);
+    if (!storePath || !fs.existsSync(storePath)) {
+      log?.warn?.(`[adp-openclaw] Cannot trim transcript: store not found at ${storePath}`);
+      return;
+    }
+
+    const raw = fs.readFileSync(storePath, "utf-8");
+    const store = JSON.parse(raw) as Record<string, { sessionId?: string; sessionFile?: string; [key: string]: unknown }>;
+
+    // Find matching session entry
+    const candidates = [sessionKey, `agent:main:${sessionKey}`];
+    let entry: { sessionId?: string; sessionFile?: string; [key: string]: unknown } | undefined;
+    for (const key of candidates) {
+      if (store[key]) {
+        entry = store[key];
+        break;
+      }
+    }
+
+    if (!entry?.sessionId) {
+      log?.info?.(`[adp-openclaw] Session entry not found for transcript trimming: ${sessionKey}`);
+      return;
+    }
+
+    // Resolve transcript file path
+    let transcriptPath: string;
+    if (entry.sessionFile) {
+      transcriptPath = entry.sessionFile;
+    } else {
+      // Fallback: same directory as sessions.json, filename = <sessionId>.jsonl
+      transcriptPath = path.join(path.dirname(storePath), `${entry.sessionId}.jsonl`);
+    }
+
+    if (!fs.existsSync(transcriptPath)) {
+      log?.info?.(`[adp-openclaw] Transcript file not found: ${transcriptPath}`);
+      return;
+    }
+
+    // Read and parse JSONL lines
+    const content = fs.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+
+    if (lines.length === 0) return;
+
+    // Parse each line into JSON entries
+    type TranscriptEntry = {
+      type?: string;
+      id?: string;
+      parentId?: string | null;
+      message?: { role?: string; content?: unknown };
+      [key: string]: unknown;
+    };
+
+    const entries: TranscriptEntry[] = [];
+    for (const line of lines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        entries.push({ _raw: line } as unknown as TranscriptEntry);
+      }
+    }
+
+    // Find the last user message entry (searching from the end)
+    let lastUserMsgIdx = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const e = entries[i];
+      if (e.type === "message" && e.message?.role === "user") {
+        lastUserMsgIdx = i;
+        break;
+      }
+    }
+
+    if (lastUserMsgIdx < 0) {
+      log?.info?.(`[adp-openclaw] No user message found in transcript to trim`);
+      return;
+    }
+
+    // Check if the last user message is at or near the end (within last few entries)
+    // This ensures we only trim the most recent aborted conversation, not old ones
+    if (lastUserMsgIdx < entries.length - 5) {
+      log?.info?.(`[adp-openclaw] Last user message is not recent enough to trim (idx=${lastUserMsgIdx}, total=${entries.length})`);
+      return;
+    }
+
+    // Truncate: keep everything before the last user message
+    const trimmedLines = lines.slice(0, lastUserMsgIdx);
+    const trimmedContent = trimmedLines.join("\n") + "\n";
+
+    fs.writeFileSync(transcriptPath, trimmedContent, "utf-8");
+
+    const removedCount = lines.length - lastUserMsgIdx;
+    log?.info?.(`[adp-openclaw] Trimmed ${removedCount} aborted entries from transcript (kept ${lastUserMsgIdx} entries)`);
+  } catch (err) {
+    log?.error?.(`[adp-openclaw] Failed to trim aborted messages from transcript: ${err}`);
+  }
+}
+
 export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
   const { wsUrl, clientToken, signKey, abortSignal, log, cfg } = params;
   const runtime = getAdpOpenclawRuntime();
@@ -255,6 +418,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             log?.info(`[adp-openclaw] Received: ${inMsg.from}: ${inMsg.text} (conv=${inMsg.conversationId}, rec=${inMsg.recordId || 'none'}, user=${JSON.stringify(inMsg.user || {})})`);
 
             // Process the message with full user identity
+            const convIdForCleanup = inMsg.conversationId || `fallback-${Date.now()}`;
             try {
               // Build user identity string for From field (like Feishu: "feishu:user_id")
               const userIdentifier = inMsg.user?.userId || inMsg.from;
@@ -582,6 +746,25 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 const cancelText = lastPartialText ? `${lastPartialText}\n\n[已停止生成]` : "[已停止生成]";
                 log?.info(`[adp-openclaw] Generation cancelled, sending outbound_end with partial text`);
                 sendOutboundEnd(cancelText);
+
+                // Mark the session as aborted so the SDK injects an "abort hint"
+                // on the next message, preventing the AI from resuming the cancelled task
+                await markSessionAborted({
+                  sessionKey: route.sessionKey,
+                  runtime,
+                  cfg,
+                  log,
+                });
+
+                // Remove the aborted user message and partial assistant reply from
+                // the JSONL transcript. Without this, the AI sees the old cancelled
+                // request in its context and may resume it instead of answering the new one.
+                await trimAbortedMessagesFromTranscript({
+                  sessionKey: route.sessionKey,
+                  runtime,
+                  cfg,
+                  log,
+                });
               }
 
               // IMPORTANT: After dispatchReplyWithBufferedBlockDispatcher completes,
@@ -595,7 +778,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
               }
             } catch (err) {
               // Clean up on error
-              activeGenerations.delete(convId);
+              activeGenerations.delete(convIdForCleanup);
               log?.error(`[adp-openclaw] Failed to process message: ${err}`);
             }
             break;