test(chat.inject): extend replay and idempotency coverage

aaronclawrsl-bot · aaronclawrsl-bot · commit 09ec74efdd6d · 2026-05-17T17:11:39.000-04:00
diff --git a/src/gateway/server-methods/chat.inject.parentid.test.ts b/src/gateway/server-methods/chat.inject.parentid.test.ts
@@ -1,7 +1,10 @@
 import fs from "node:fs";
 import { describe, expect, it } from "vitest";
 import { onSessionTranscriptUpdate } from "../../sessions/transcript-events.js";
-import { appendInjectedAssistantMessageToTranscript } from "./chat-transcript-inject.js";
+import {
+  appendInjectedAssistantMessageToTranscript,
+  appendInjectedUserMessageToTranscript,
+} from "./chat-transcript-inject.js";
 import { createTranscriptFixtureSync } from "./chat.test-helpers.js";
 
 function readTranscriptLines(transcriptPath: string): string[] {
@@ -125,4 +128,271 @@ describe("gateway chat.inject transcript writes", () => {
       fs.rmSync(dir, { recursive: true, force: true });
     }
   });
+
+  it("appends an injected user message", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-user-",
+      sessionId: "sess-user",
+    });
+
+    try {
+      const appended = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "hello from user",
+      });
+
+      expect(appended.ok).toBe(true);
+      expect(appended.messageId).toBeTypeOf("string");
+
+      const lines = readTranscriptLines(transcriptPath);
+      const last = JSON.parse(lines.at(-1) as string) as {
+        message?: { role?: string; content?: Array<{ type?: string; text?: string }> };
+      };
+      expect(last.message?.role).toBe("user");
+      expect(last.message?.content?.[0]?.type).toBe("text");
+      expect(last.message?.content?.[0]?.text).toBe("hello from user");
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("dedupes concurrent identical idempotent injects (race-safe)", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-race-",
+      sessionId: "sess-race",
+    });
+
+    try {
+      const idempotencyKey = "race-key-001";
+      const concurrency = 16;
+      const results = await Promise.all(
+        Array.from({ length: concurrency }, () =>
+          appendInjectedUserMessageToTranscript({
+            transcriptPath,
+            message: "concurrent hello",
+            idempotencyKey,
+          }),
+        ),
+      );
+
+      // Every call must succeed and return the same canonical messageId.
+      const messageIds = new Set<string>();
+      let dedupedCount = 0;
+      for (const r of results) {
+        expect(r.ok).toBe(true);
+        expect(r.messageId).toBeTypeOf("string");
+        messageIds.add(r.messageId as string);
+        if (r.deduped) {
+          dedupedCount += 1;
+        }
+      }
+      expect(messageIds.size).toBe(1);
+      // Exactly one call writes; the rest must be deduped.
+      expect(dedupedCount).toBe(concurrency - 1);
+
+      // Disk state must reflect a single persisted entry for the key.
+      const lines = readTranscriptLines(transcriptPath);
+      const matches = lines.filter((line) => {
+        try {
+          const parsed = JSON.parse(line) as { message?: { idempotencyKey?: unknown } };
+          return parsed?.message?.idempotencyKey === idempotencyKey;
+        } catch {
+          return false;
+        }
+      });
+      expect(matches).toHaveLength(1);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns the original persisted payload on idempotent replay", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-replay-",
+      sessionId: "sess-replay",
+    });
+
+    try {
+      const idempotencyKey = "replay-key-001";
+      const first = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "first payload wins",
+        idempotencyKey,
+      });
+      const replay = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "second payload should be ignored",
+        idempotencyKey,
+      });
+
+      expect(first.ok).toBe(true);
+      expect(replay.ok).toBe(true);
+      expect(replay.deduped).toBe(true);
+      expect(replay.messageId).toBe(first.messageId);
+      expect(
+        (replay.message as { content?: Array<{ text?: string }> } | undefined)?.content?.[0]?.text,
+      ).toBe("first payload wins");
+
+      const lines = readTranscriptLines(transcriptPath);
+      const messages: Array<{
+        type?: string;
+        message?: { content?: Array<{ text?: string }> };
+      }> = lines
+        .map(
+          (line) =>
+            JSON.parse(line) as { type?: string; message?: { content?: Array<{ text?: string }> } },
+        )
+        .filter((entry) => entry.type === "message");
+      expect(messages).toHaveLength(1);
+      expect(messages[0]?.message?.content?.[0]?.text).toBe("first payload wins");
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("does not deduplicate when no idempotencyKey is provided", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-nokey-",
+      sessionId: "sess-nokey",
+    });
+
+    try {
+      const first = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "hello no key",
+      });
+      const second = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "hello no key",
+      });
+
+      expect(first.ok).toBe(true);
+      expect(second.ok).toBe(true);
+      // Without an idempotency key, both writes must land on disk.
+      expect(first.deduped).toBeFalsy();
+      expect(second.deduped).toBeFalsy();
+      expect(first.messageId).not.toBe(second.messageId);
+
+      const lines = readTranscriptLines(transcriptPath);
+      const messages = lines
+        .map((line) => JSON.parse(line) as { type?: string })
+        .filter((e) => e.type === "message");
+      expect(messages).toHaveLength(2);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("does not emit a transcript update event on idempotent replay", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-noevent-",
+      sessionId: "sess-noevent",
+    });
+    const updates: unknown[] = [];
+    const unsubscribe = onSessionTranscriptUpdate((u) => updates.push(u));
+
+    try {
+      const idempotencyKey = "noevent-key-001";
+      await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "original",
+        idempotencyKey,
+      });
+      const eventCountAfterFirst = updates.length;
+
+      await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "replay - should not emit",
+        idempotencyKey,
+      });
+
+      // First write must have emitted exactly one event.
+      expect(eventCountAfterFirst).toBe(1);
+      // Replay must not emit any additional events.
+      expect(updates).toHaveLength(1);
+    } finally {
+      unsubscribe();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("deduplicates assistant-role injects by idempotency key", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-asst-dedup-",
+      sessionId: "sess-asst-dedup",
+    });
+
+    try {
+      const idempotencyKey = "asst-dedup-key-001";
+      const first = await appendInjectedAssistantMessageToTranscript({
+        transcriptPath,
+        message: "assistant first payload",
+        idempotencyKey,
+      });
+      const replay = await appendInjectedAssistantMessageToTranscript({
+        transcriptPath,
+        message: "assistant second payload - must be ignored",
+        idempotencyKey,
+      });
+
+      expect(first.ok).toBe(true);
+      expect(first.deduped).toBeFalsy();
+      expect(replay.ok).toBe(true);
+      expect(replay.deduped).toBe(true);
+      expect(replay.messageId).toBe(first.messageId);
+
+      // Only one entry on disk.
+      const lines = readTranscriptLines(transcriptPath);
+      const messages = lines
+        .map((line) => JSON.parse(line) as { type?: string })
+        .filter((e) => e.type === "message");
+      expect(messages).toHaveLength(1);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("distinct idempotency keys produce distinct entries", async () => {
+    const { dir, transcriptPath } = createTranscriptFixtureSync({
+      prefix: "openclaw-chat-inject-multikey-",
+      sessionId: "sess-multikey",
+    });
+
+    try {
+      const r1 = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "message for key A",
+        idempotencyKey: "key-A",
+      });
+      const r2 = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "message for key B",
+        idempotencyKey: "key-B",
+      });
+      // Replay key A - must not collide with key B.
+      const r1replay = await appendInjectedUserMessageToTranscript({
+        transcriptPath,
+        message: "key A replay",
+        idempotencyKey: "key-A",
+      });
+
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r1.deduped).toBeFalsy();
+      expect(r2.deduped).toBeFalsy();
+      expect(r1.messageId).not.toBe(r2.messageId);
+
+      expect(r1replay.deduped).toBe(true);
+      expect(r1replay.messageId).toBe(r1.messageId);
+
+      // Two distinct entries on disk.
+      const lines = readTranscriptLines(transcriptPath);
+      const messages = lines
+        .map((line) => JSON.parse(line) as { type?: string })
+        .filter((e) => e.type === "message");
+      expect(messages).toHaveLength(2);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/src/gateway/server-methods/chat.ts b/src/gateway/server-methods/chat.ts
@@ -121,6 +121,9 @@ import {
   appendInjectedAssistantMessageToTranscript,
   appendInjectedUserMessageToTranscript,
 } from "./chat-transcript-inject.js";
+import type { GatewayInjectedTranscriptAppendResult } from "./chat-transcript-inject.js";
+
+type TranscriptAppendResult = GatewayInjectedTranscriptAppendResult;
 import {
   buildWebchatAssistantMessageFromReplyPayloads,
   buildWebchatAudioContentBlocksFromReplyPayloads,
@@ -131,15 +134,6 @@ import type {
   GatewayRequestHandlers,
 } from "./types.js";
 
-type TranscriptAppendResult = {
-  ok: boolean;
-  messageId?: string;
-  message?: Record<string, unknown>;
-  /** True when an existing entry with matching idempotencyKey was returned. */
-  deduped?: boolean;
-  error?: string;
-};
-
 type AbortOrigin = "rpc" | "stop-command";
 
 type AbortedPartialSnapshot = {
@@ -1520,6 +1514,8 @@ function createChatAbortOps(context: GatewayRequestContext): ChatAbortOps {
     chatDeltaSentAt: context.chatDeltaSentAt,
     chatDeltaLastBroadcastLen: context.chatDeltaLastBroadcastLen,
     chatDeltaLastBroadcastText: context.chatDeltaLastBroadcastText,
+    agentDeltaSentAt: context.agentDeltaSentAt,
+    bufferedAgentEvents: context.bufferedAgentEvents,
     chatAbortedRuns: context.chatAbortedRuns,
     removeChatRun: context.removeChatRun,
     agentRunSeq: context.agentRunSeq,
diff --git a/src/plugins/registry.runtime-config.test.ts b/src/plugins/registry.runtime-config.test.ts
@@ -58,9 +58,9 @@ describe("plugin registry runtime config scope", () => {
       loadConfig,
       writeConfigFile,
     } satisfies PluginRuntime["config"];
-    const runtime = createPluginRuntime();
-    runtime.config = configRuntime;
-    const pluginRegistry = createTestRegistry(runtime);
+    const pluginRegistry = createTestRegistry({
+      config: configRuntime,
+    } as unknown as PluginRuntime);
     const record = createPluginRecord({
       id: "legacy-plugin",
       name: "Legacy Plugin",
