adp-openclaw 0.0.57 → 0.0.58

package/package.json

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

package/src/monitor.ts

@@ -24,7 +24,6 @@ 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" };
 
@@ -165,120 +164,6 @@ 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();
@@ -748,23 +633,15 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 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
+                // on the next message, preventing the AI from resuming the cancelled task.
+                // This aligns with openclaw's behavior: keep all transcript history intact,
+                // only set abortedLastRun=true so next turn gets "Resume carefully" hint.
                 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,