fix(discord): avoid duplicate typing keepalive for tool replies

Andrew Meyer · Andrew Meyer · commit 3439ab10b616 · 2026-05-19T15:25:52.000-05:00
diff --git a/extensions/discord/src/monitor/message-handler.process.test.ts b/extensions/discord/src/monitor/message-handler.process.test.ts
@@ -16,6 +16,11 @@ const sendMocks = vi.hoisted(() => ({
     (channelId: string, messageId: string, emoji: string, opts?: unknown) => Promise<void>
   >(async () => {}),
 }));
+const typingMocks = vi.hoisted(() => ({
+  sendTyping: vi.fn<(params: { rest: unknown; channelId: string }) => Promise<void>>(
+    async () => {},
+  ),
+}));
 function createMockDraftStream() {
   let messageId: string | undefined = "preview-1";
   return {
@@ -71,6 +76,10 @@ vi.mock("../send.js", () => ({
   },
 }));
 
+vi.mock("./typing.js", () => ({
+  sendTyping: (params: { rest: unknown; channelId: string }) => typingMocks.sendTyping(params),
+}));
+
 const discordTargetMocks = vi.hoisted(() => ({
   resolveDiscordTargetChannelId: vi.fn(async (target: string, _opts?: unknown) => ({
     channelId: target === "user:u1" ? "dm-u1" : target,
@@ -139,6 +148,7 @@ type DispatchInboundParams = {
     }) => Promise<void> | void;
     onReplyStart?: () => Promise<void> | void;
     sourceReplyDeliveryMode?: "automatic" | "message_tool_only";
+    typingKeepalive?: boolean;
     disableBlockStreaming?: boolean;
     suppressDefaultToolProgressMessages?: boolean;
     queuedDeliveryCorrelations?: Array<{ begin: () => () => void }>;
@@ -380,6 +390,7 @@ beforeEach(() => {
   vi.useRealTimers();
   sendMocks.reactMessageDiscord.mockClear();
   sendMocks.removeReactionDiscord.mockClear();
+  typingMocks.sendTyping.mockClear();
   discordTargetMocks.resolveDiscordTargetChannelId.mockClear();
   editMessageDiscord.mockClear();
   deliverDiscordReply.mockClear();
@@ -650,6 +661,27 @@ function expectSinglePreviewEdit() {
   expect(deliverDiscordReply).not.toHaveBeenCalled();
 }
 
+describe("processDiscordMessage typing", () => {
+  it("does not start a nested Discord typing keepalive from channel callbacks", async () => {
+    vi.useFakeTimers();
+    try {
+      dispatchInboundMessage.mockImplementationOnce(async (params?: DispatchInboundParams) => {
+        await params?.replyOptions?.onReplyStart?.();
+        await vi.advanceTimersByTimeAsync(3_500);
+        return createNoQueuedDispatchResult();
+      });
+
+      const ctx = await createAutomaticSourceDeliveryContext();
+
+      await runProcessDiscordMessage(ctx);
+
+      expect(typingMocks.sendTyping).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
+
 describe("processDiscordMessage ack reactions", () => {
   it("drops bot-loop-suppressed messages before Discord side effects", async () => {
     const botLoopProtection: ChannelBotLoopProtectionFacts = {
@@ -1275,11 +1307,34 @@ describe("processDiscordMessage session routing", () => {
 
     expectRecordFields(requireRecord(getLastDispatchReplyOptions(), "dispatch reply options"), {
       sourceReplyDeliveryMode: "message_tool_only",
+      typingKeepalive: false,
       disableBlockStreaming: true,
     });
     expect(createDiscordDraftStream).not.toHaveBeenCalled();
   });
 
+  it("preserves core typing keepalive when message-tool guild replies configure typing mode", async () => {
+    const ctx = await createBaseContext({
+      shouldRequireMention: false,
+      effectiveWasMentioned: false,
+      cfg: {
+        messages: {
+          groupChat: { visibleReplies: "message_tool" },
+        },
+        session: {
+          store: "/tmp/openclaw-discord-process-test-sessions.json",
+          typingMode: "message",
+        },
+      },
+      route: BASE_CHANNEL_ROUTE,
+    });
+
+    await runProcessDiscordMessage(ctx);
+
+    expect(getLastDispatchReplyOptions()?.sourceReplyDeliveryMode).toBe("message_tool_only");
+    expect(getLastDispatchReplyOptions()?.typingKeepalive).toBeUndefined();
+  });
+
   it("sends the configured ack while suppressing automatic status reactions for always-on guild replies", async () => {
     const ctx = await createBaseContext({
       shouldRequireMention: false,
diff --git a/extensions/discord/src/monitor/message-handler.process.ts b/extensions/discord/src/monitor/message-handler.process.ts
@@ -220,6 +220,9 @@ export async function processDiscordMessage(
     },
   });
   const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+  const configuredTypingMode = cfg.session?.typingMode ?? cfg.agents?.defaults?.typingMode;
+  const shouldDisableCoreTypingKeepalive =
+    sourceRepliesAreToolOnly && configuredTypingMode === undefined;
   const ackReaction = resolveAckReaction(cfg, route.agentId, {
     channel: "discord",
     accountId,
@@ -424,8 +427,9 @@ export async function processDiscordMessage(
           error: err,
         });
       },
-      // Long tool-heavy runs are expected on Discord; keep heartbeats alive.
+      // The core reply typing controller owns typing for this path.
       maxDurationMs: DISCORD_TYPING_MAX_DURATION_MS,
+      keepaliveIntervalMs: 0,
     },
   });
   const tableMode = resolveMarkdownTableMode({
@@ -794,6 +798,7 @@ export async function processDiscordMessage(
             abortSignal,
             skillFilter: channelConfig?.skills,
             sourceReplyDeliveryMode,
+            typingKeepalive: shouldDisableCoreTypingKeepalive ? false : undefined,
             queuedDeliveryCorrelations: isRoomEvent
               ? [{ begin: beginDeliveryCorrelation }]
               : undefined,
diff --git a/src/auto-reply/get-reply-options.types.ts b/src/auto-reply/get-reply-options.types.ts
@@ -60,6 +60,8 @@ export type GetReplyOptions = {
   /** Called when the typing controller cleans up (e.g., run ended with NO_REPLY). */
   onTypingCleanup?: () => void;
   onTypingController?: (typing: TypingController) => void;
+  /** If false, send only the initial typing signal without periodic keepalive refreshes. */
+  typingKeepalive?: boolean;
   isHeartbeat?: boolean;
   /** Policy-level typing control for run classes (user/system/internal/heartbeat). */
   typingPolicy?: TypingPolicy;
diff --git a/src/auto-reply/reply/get-reply.ts b/src/auto-reply/reply/get-reply.ts
@@ -309,6 +309,7 @@ export async function getReplyFromConfig(
     onReplyStart: opts?.onReplyStart,
     onCleanup: opts?.onTypingCleanup,
     typingIntervalSeconds,
+    keepalive: opts?.typingKeepalive ?? true,
     silentToken: SILENT_REPLY_TOKEN,
     log: defaultRuntime.log,
   });
diff --git a/src/auto-reply/reply/reply-utils.test.ts b/src/auto-reply/reply/reply-utils.test.ts
@@ -386,6 +386,27 @@ describe("typing controller", () => {
     await vi.advanceTimersByTimeAsync(5_000);
     expect(onReplyStart).toHaveBeenCalledTimes(1);
   });
+
+  it("can send the first typing signal without periodic keepalive refreshes", async () => {
+    vi.useFakeTimers();
+    const onReplyStart = vi.fn();
+    const typing = createTypingController({
+      onReplyStart,
+      typingIntervalSeconds: 1,
+      typingTtlMs: 30_000,
+      keepalive: false,
+    });
+
+    await typing.startTypingLoop();
+    expect(onReplyStart).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(onReplyStart).toHaveBeenCalledTimes(1);
+
+    await typing.startTypingLoop();
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(onReplyStart).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe("resolveTypingMode", () => {
@@ -433,6 +454,17 @@ describe("resolveTypingMode", () => {
         },
         expected: "message",
       },
+      {
+        name: "configured instant typing mode wins over message-tool-only default",
+        input: {
+          configured: "instant" as const,
+          isGroupChat: true,
+          wasMentioned: false,
+          isHeartbeat: false,
+          sourceReplyDeliveryMode: "message_tool_only" as const,
+        },
+        expected: "instant",
+      },
       {
         name: "default mentioned group chat",
         input: {
diff --git a/src/auto-reply/reply/typing.ts b/src/auto-reply/reply/typing.ts
@@ -19,6 +19,7 @@ export function createTypingController(params: {
   onCleanup?: () => void;
   typingIntervalSeconds?: number;
   typingTtlMs?: number;
+  keepalive?: boolean;
   silentToken?: string;
   log?: (message: string) => void;
 }): TypingController {
@@ -27,6 +28,7 @@ export function createTypingController(params: {
     onCleanup,
     typingIntervalSeconds = 6,
     typingTtlMs = 2 * 60_000,
+    keepalive = true,
     silentToken = SILENT_REPLY_TOKEN,
     log,
   } = params;
@@ -188,6 +190,10 @@ export function createTypingController(params: {
     if (!onReplyStart) {
       return;
     }
+    if (!keepalive) {
+      await ensureStart();
+      return;
+    }
     if (typingLoop.isRunning()) {
       return;
     }
