adp-openclaw 0.0.56 → 0.0.57

package/package.json

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

package/src/monitor.ts

@@ -24,6 +24,7 @@ import {
 } 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" };
 
@@ -164,6 +165,120 @@ async function markSessionAborted(params: {
   }
 }
 
+/**
+ * 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();
@@ -640,6 +755,16 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                   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,