Discord: settle completed button interactions cleanly (#28)

* Discord: clear sandbox approval buttons

* Discord: finish plan questionnaires cleanly

Author: huntharo

src/controller.test.ts

@@ -537,6 +537,229 @@ describe("Discord controller flows", () => {
     expect(sendComponentMessage).not.toHaveBeenCalled();
   });
 
+  it("acknowledges and clears Discord pending-input buttons by message id", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertPendingRequest({
+      requestId: "pending-1",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      state: {
+        requestId: "pending-1",
+        options: ["Approve Once", "Cancel"],
+        expiresAt: Date.now() + 60_000,
+      },
+      updatedAt: Date.now(),
+    });
+    const callback = await (controller as any).store.putCallback({
+      kind: "pending-input",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      requestId: "pending-1",
+      actionIndex: 0,
+    });
+    const acknowledge = vi.fn(async () => {});
+    const clearComponents = vi.fn(async () => {});
+    const reply = vi.fn(async () => {});
+    const followUp = vi.fn(async () => {});
+    const submitPendingInput = vi.fn(async () => true);
+    (controller as any).activeRuns.set("discord::default::channel:chan-1::", {
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      workspaceDir: "/repo/openclaw",
+      mode: "default",
+      handle: {
+        result: Promise.resolve({ threadId: "thread-1", text: "done" }),
+        queueMessage: vi.fn(async () => false),
+        submitPendingInput,
+        submitPendingInputPayload: vi.fn(async () => false),
+        interrupt: vi.fn(async () => {}),
+        isAwaitingInput: vi.fn(() => true),
+        getThreadId: vi.fn(() => "thread-1"),
+      },
+    });
+
+    await controller.handleDiscordInteractive({
+      channel: "discord",
+      accountId: "default",
+      interactionId: "interaction-1",
+      conversationId: "channel:chan-1",
+      auth: { isAuthorizedSender: true },
+      interaction: {
+        kind: "button",
+        data: `codexapp:${callback.token}`,
+        namespace: "codexapp",
+        payload: callback.token,
+        messageId: "message-1",
+      },
+      senderId: "user-1",
+      senderUsername: "Ada",
+      respond: {
+        acknowledge,
+        reply,
+        followUp,
+        editMessage: vi.fn(async () => {}),
+        clearComponents,
+      },
+    } as any);
+
+    expect(submitPendingInput).toHaveBeenCalledWith(0);
+    expect(acknowledge).toHaveBeenCalledTimes(1);
+    expect(clearComponents).not.toHaveBeenCalled();
+    expect(discordSdkState.editDiscordComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      "message-1",
+      {
+        text: "Sent to Codex.",
+      },
+      expect.objectContaining({ accountId: "default" }),
+    );
+    expect(reply).not.toHaveBeenCalled();
+    expect(followUp).not.toHaveBeenCalled();
+  });
+
+  it("does not send a second Discord response after completing a questionnaire", async () => {
+    const { controller } = await createControllerHarness();
+    await (controller as any).store.upsertPendingRequest({
+      requestId: "questionnaire-1",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/repo/openclaw",
+      state: {
+        requestId: "questionnaire-1",
+        options: [],
+        expiresAt: Date.now() + 60_000,
+        questionnaire: {
+          currentIndex: 1,
+          awaitingFreeform: false,
+          questions: [
+            {
+              index: 0,
+              id: "milk",
+              header: "Milk",
+              prompt: "Do you like milk on cereal?",
+              options: [
+                { key: "A", label: "Yes", description: "Sure." },
+                { key: "B", label: "No", description: "Nope." },
+              ],
+            },
+            {
+              index: 1,
+              id: "type",
+              header: "Type",
+              prompt: "What kind of milk?",
+              options: [
+                { key: "A", label: "Whole", description: "Richer." },
+                { key: "B", label: "2%", description: "Lighter." },
+              ],
+            },
+          ],
+          answers: [
+            {
+              kind: "option",
+              optionKey: "A",
+              optionLabel: "Yes",
+            },
+            null,
+          ],
+        },
+      },
+      updatedAt: Date.now(),
+    });
+    const callback = await (controller as any).store.putCallback({
+      kind: "pending-questionnaire",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      requestId: "questionnaire-1",
+      questionIndex: 1,
+      action: "select",
+      optionIndex: 0,
+    });
+    const acknowledge = vi.fn(async () => {});
+    const clearComponents = vi.fn(async () => {});
+    const reply = vi.fn(async () => {});
+    const followUp = vi.fn(async () => {});
+    const submitPendingInputPayload = vi.fn(async () => true);
+    (controller as any).activeRuns.set("discord::default::channel:chan-1::", {
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "channel:chan-1",
+      },
+      workspaceDir: "/repo/openclaw",
+      mode: "plan",
+      handle: {
+        result: Promise.resolve({ threadId: "thread-1", text: "done" }),
+        queueMessage: vi.fn(async () => false),
+        submitPendingInput: vi.fn(async () => false),
+        submitPendingInputPayload,
+        interrupt: vi.fn(async () => {}),
+        isAwaitingInput: vi.fn(() => true),
+        getThreadId: vi.fn(() => "thread-1"),
+      },
+    });
+
+    await controller.handleDiscordInteractive({
+      channel: "discord",
+      accountId: "default",
+      interactionId: "interaction-1",
+      conversationId: "channel:chan-1",
+      auth: { isAuthorizedSender: true },
+      interaction: {
+        kind: "button",
+        data: `codexapp:${callback.token}`,
+        namespace: "codexapp",
+        payload: callback.token,
+        messageId: "message-1",
+      },
+      senderId: "user-1",
+      senderUsername: "Ada",
+      respond: {
+        acknowledge,
+        reply,
+        followUp,
+        editMessage: vi.fn(async () => {}),
+        clearComponents,
+      },
+    } as any);
+
+    expect(submitPendingInputPayload).toHaveBeenCalledWith({
+      answers: {
+        milk: { answers: ["Yes"] },
+        type: { answers: ["Whole"] },
+      },
+    });
+    expect(acknowledge).toHaveBeenCalledTimes(1);
+    expect(clearComponents).not.toHaveBeenCalled();
+    expect(discordSdkState.editDiscordComponentMessage).toHaveBeenCalledWith(
+      "channel:chan-1",
+      "message-1",
+      {
+        text: "Recorded your answers and sent them to Codex.",
+      },
+      expect.objectContaining({ accountId: "default" }),
+    );
+    expect(reply).not.toHaveBeenCalled();
+    expect(followUp).not.toHaveBeenCalled();
+  });
+
   it("normalizes raw Discord callback conversation ids for guild interactions", async () => {
     const { controller, sendComponentMessage } = await createControllerHarness();
     const callback = await (controller as any).store.putCallback({
@@ -1742,6 +1965,7 @@ describe("Discord controller flows", () => {
     }));
     (controller as any).client.startTurn = startTurn;
     const reply = vi.fn(async () => {});
+    const followUp = vi.fn(async () => {});
 
     await controller.handleDiscordInteractive({
       channel: "discord",
@@ -1761,13 +1985,14 @@ describe("Discord controller flows", () => {
       respond: {
         acknowledge: vi.fn(async () => {}),
         reply,
-        followUp: vi.fn(async () => {}),
+        followUp,
         editMessage: vi.fn(async () => {}),
         clearComponents: vi.fn(async () => {}),
       },
     } as any);
 
-    expect(reply).toHaveBeenCalledWith({ text: "Sent the plan to Codex.", ephemeral: true });
+    expect(reply).not.toHaveBeenCalled();
+    expect(followUp).toHaveBeenCalledWith({ text: "Sent the plan to Codex.", ephemeral: true });
     expect(startTurn).toHaveBeenCalledWith(
       expect.objectContaining({
         prompt: "Implement the plan.",

src/controller.ts

@@ -841,21 +841,66 @@ export class CodexPluginController {
       conversationId,
       parentConversationId: callback.conversation.parentConversationId ?? ctx.parentConversationId,
     };
+    let interactionSettled = false;
     try {
       if (callback.kind === "resume-thread") {
-        await ctx.respond.acknowledge().catch(() => undefined);
+        await ctx.respond
+          .acknowledge()
+          .then(() => {
+            interactionSettled = true;
+          })
+          .catch(() => undefined);
       }
       await this.dispatchCallbackAction(callback, {
         conversation,
         clear: async () => {
+          const messageId = ctx.interaction.messageId?.trim();
+          if ((callback.kind === "pending-input" || callback.kind === "pending-questionnaire") && messageId) {
+            await ctx.respond
+              .acknowledge()
+              .then(() => {
+                interactionSettled = true;
+              })
+              .catch(() => undefined);
+            const completionText =
+              callback.kind === "pending-questionnaire"
+                ? "Recorded your answers and sent them to Codex."
+                : "Sent to Codex.";
+            await editDiscordComponentMessage(
+              conversation.conversationId,
+              messageId,
+              {
+                text: completionText,
+              },
+              {
+                accountId: conversation.accountId,
+              },
+            ).catch((error) => {
+              this.api.logger.warn(
+                `codex discord ${callback.kind} clear failed conversation=${conversationId}: ${String(error)}`,
+              );
+            });
+            return;
+          }
           try {
             await ctx.respond.clearComponents();
+            interactionSettled = true;
           } catch {
-            await ctx.respond.acknowledge().catch(() => undefined);
+            await ctx.respond
+              .acknowledge()
+              .then(() => {
+                interactionSettled = true;
+              })
+              .catch(() => undefined);
           }
         },
         reply: async (text) => {
+          if (interactionSettled) {
+            await ctx.respond.followUp({ text, ephemeral: true });
+            return;
+          }
           await ctx.respond.reply({ text, ephemeral: true });
+          interactionSettled = true;
         },
         editPicker: async (picker) => {
           this.api.logger.debug(
@@ -867,6 +912,7 @@ export class CodexPluginController {
             await ctx.respond.editMessage({
               components: builtPicker.components,
             });
+            interactionSettled = true;
             if (messageId) {
               registerBuiltDiscordComponentMessage({
                 buildResult: builtPicker,
@@ -881,7 +927,12 @@ export class CodexPluginController {
             );
             if (messageId) {
               if (!detail.includes("already been acknowledged")) {
-                await ctx.respond.acknowledge().catch(() => undefined);
+                await ctx.respond
+                  .acknowledge()
+                  .then(() => {
+                    interactionSettled = true;
+                  })
+                  .catch(() => undefined);
               }
               await editDiscordComponentMessage(
                 conversation.conversationId,
@@ -929,12 +980,12 @@ export class CodexPluginController {
     } catch (error) {
       const detail = error instanceof Error ? error.stack ?? error.message : String(error);
       this.api.logger.warn(`codex discord interactive failed conversation=${conversationId}: ${detail}`);
-      await ctx.respond
-        .reply({
-          text: "Codex hit an error handling that action. Please retry the command.",
-          ephemeral: true,
-        })
-        .catch(() => undefined);
+      const errorReply = {
+        text: "Codex hit an error handling that action. Please retry the command.",
+        ephemeral: true,
+      } as const;
+      const sendError = interactionSettled ? ctx.respond.followUp(errorReply) : ctx.respond.reply(errorReply);
+      await sendError.catch(() => undefined);
     }
   }
 
@@ -2858,7 +2909,9 @@ export class CodexPluginController {
         return;
       }
       await this.store.removeCallback(callback.token);
-      await responders.reply("Sent to Codex.");
+      if (callback.conversation.channel !== "discord") {
+        await responders.reply("Sent to Codex.");
+      }
       return;
     }
     if (callback.kind === "pending-questionnaire") {
@@ -2952,7 +3005,9 @@ export class CodexPluginController {
         }
         await responders.clear().catch(() => undefined);
         await this.store.removePendingRequest(pending.requestId);
-        await responders.reply("Recorded your answers and sent them to Codex.");
+        if (callback.conversation.channel !== "discord") {
+          await responders.reply("Recorded your answers and sent them to Codex.");
+        }
         return;
       }
       await this.sendPendingQuestionnaire(callback.conversation, pending.state, {