Plugins: add Discord interaction surface

src/plugins/interactive.test.ts

@@ -88,4 +88,62 @@ describe("plugin interactive handlers", () => {
       error: 'Interactive handler namespace "codex" already registered by plugin "plugin-a"',
     });
   });
+
+  it("routes Discord interactions by namespace and dedupes interaction ids", async () => {
+    const handler = vi.fn(async () => ({ handled: true }));
+    expect(
+      registerPluginInteractiveHandler("codex-plugin", {
+        channel: "discord",
+        namespace: "codex",
+        handler,
+      }),
+    ).toEqual({ ok: true });
+
+    const baseParams = {
+      channel: "discord" as const,
+      data: "codex:approve:thread-1",
+      interactionId: "ix-1",
+      ctx: {
+        accountId: "default",
+        interactionId: "ix-1",
+        conversationId: "channel-1",
+        parentConversationId: "parent-1",
+        guildId: "guild-1",
+        senderId: "user-1",
+        senderUsername: "ada",
+        auth: { isAuthorizedSender: true },
+        interaction: {
+          kind: "button" as const,
+          messageId: "message-1",
+          values: ["allow"],
+        },
+      },
+      respond: {
+        acknowledge: vi.fn(async () => {}),
+        reply: vi.fn(async () => {}),
+        followUp: vi.fn(async () => {}),
+        editMessage: vi.fn(async () => {}),
+        clearComponents: vi.fn(async () => {}),
+      },
+    };
+
+    const first = await dispatchPluginInteractiveHandler(baseParams);
+    const duplicate = await dispatchPluginInteractiveHandler(baseParams);
+
+    expect(first).toEqual({ matched: true, handled: true, duplicate: false });
+    expect(duplicate).toEqual({ matched: true, handled: true, duplicate: true });
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channel: "discord",
+        conversationId: "channel-1",
+        interaction: expect.objectContaining({
+          namespace: "codex",
+          payload: "approve:thread-1",
+          messageId: "message-1",
+          values: ["allow"],
+        }),
+      }),
+    );
+  });
 });

src/plugins/interactive.ts

@@ -1,7 +1,10 @@
 import { createDedupeCache } from "../infra/dedupe.js";
 import type {
+  PluginInteractiveDiscordHandlerContext,
   PluginInteractiveButtons,
+  PluginInteractiveDiscordHandlerRegistration,
   PluginInteractiveHandlerRegistration,
+  PluginInteractiveTelegramHandlerRegistration,
   PluginInteractiveTelegramHandlerContext,
 } from "./types.js";
 
@@ -83,12 +86,21 @@ export function registerPluginInteractiveHandler(
       error: `Interactive handler namespace "${namespace}" already registered by plugin "${existing.pluginId}"`,
     };
   }
-  interactiveHandlers.set(key, {
-    ...registration,
-    namespace,
-    channel: registration.channel,
-    pluginId,
-  });
+  if (registration.channel === "telegram") {
+    interactiveHandlers.set(key, {
+      ...registration,
+      namespace,
+      channel: "telegram",
+      pluginId,
+    });
+  } else {
+    interactiveHandlers.set(key, {
+      ...registration,
+      namespace,
+      channel: "discord",
+      pluginId,
+    });
+  }
   return { ok: true };
 }
 
@@ -123,34 +135,128 @@ export async function dispatchPluginInteractiveHandler(params: {
     clearButtons: () => Promise<void>;
     deleteMessage: () => Promise<void>;
   };
+}): Promise<InteractiveDispatchResult>;
+export async function dispatchPluginInteractiveHandler(params: {
+  channel: "discord";
+  data: string;
+  interactionId: string;
+  ctx: Omit<PluginInteractiveDiscordHandlerContext, "interaction" | "respond" | "channel"> & {
+    interaction: Omit<
+      PluginInteractiveDiscordHandlerContext["interaction"],
+      "data" | "namespace" | "payload"
+    >;
+  };
+  respond: PluginInteractiveDiscordHandlerContext["respond"];
+}): Promise<InteractiveDispatchResult>;
+export async function dispatchPluginInteractiveHandler(params: {
+  channel: "telegram" | "discord";
+  data: string;
+  callbackId?: string;
+  interactionId?: string;
+  ctx:
+    | (Omit<PluginInteractiveTelegramHandlerContext, "callback" | "respond" | "channel"> & {
+        callbackMessage: {
+          messageId: number;
+          chatId: string;
+          messageText?: string;
+        };
+      })
+    | (Omit<PluginInteractiveDiscordHandlerContext, "interaction" | "respond" | "channel"> & {
+        interaction: Omit<
+          PluginInteractiveDiscordHandlerContext["interaction"],
+          "data" | "namespace" | "payload"
+        >;
+      });
+  respond:
+    | {
+        reply: (params: { text: string; buttons?: PluginInteractiveButtons }) => Promise<void>;
+        editMessage: (params: {
+          text: string;
+          buttons?: PluginInteractiveButtons;
+        }) => Promise<void>;
+        editButtons: (params: { buttons: PluginInteractiveButtons }) => Promise<void>;
+        clearButtons: () => Promise<void>;
+        deleteMessage: () => Promise<void>;
+      }
+    | PluginInteractiveDiscordHandlerContext["respond"];
 }): Promise<InteractiveDispatchResult> {
   const match = resolveNamespaceMatch(params.channel, params.data);
   if (!match) {
     return { matched: false, handled: false, duplicate: false };
   }
 
-  if (callbackDedupe.check(params.callbackId)) {
+  const dedupeKey =
+    params.channel === "telegram" ? params.callbackId?.trim() : params.interactionId?.trim();
+  if (dedupeKey && callbackDedupe.check(dedupeKey)) {
     return { matched: true, handled: true, duplicate: true };
   }
 
-  const { callbackMessage, ...handlerContext } = params.ctx;
-  const result = await match.registration.handler({
-    ...handlerContext,
-    channel: "telegram",
-    callback: {
-      data: params.data,
-      namespace: match.namespace,
-      payload: match.payload,
-      messageId: callbackMessage.messageId,
-      chatId: callbackMessage.chatId,
-      messageText: callbackMessage.messageText,
-    },
-    respond: params.respond,
-  });
+  let result:
+    | ReturnType<PluginInteractiveTelegramHandlerRegistration["handler"]>
+    | ReturnType<PluginInteractiveDiscordHandlerRegistration["handler"]>;
+  if (params.channel === "telegram") {
+    const { callbackMessage, ...handlerContext } = params.ctx as Omit<
+      PluginInteractiveTelegramHandlerContext,
+      "callback" | "respond" | "channel"
+    > & {
+      callbackMessage: {
+        messageId: number;
+        chatId: string;
+        messageText?: string;
+      };
+    };
+    result = (
+      match.registration as RegisteredInteractiveHandler &
+        PluginInteractiveTelegramHandlerRegistration
+    ).handler({
+      ...handlerContext,
+      channel: "telegram",
+      callback: {
+        data: params.data,
+        namespace: match.namespace,
+        payload: match.payload,
+        messageId: callbackMessage.messageId,
+        chatId: callbackMessage.chatId,
+        messageText: callbackMessage.messageText,
+      },
+      respond: params.respond as PluginInteractiveTelegramHandlerContext["respond"],
+    });
+  } else {
+    result = (
+      match.registration as RegisteredInteractiveHandler &
+        PluginInteractiveDiscordHandlerRegistration
+    ).handler({
+      ...(params.ctx as Omit<
+        PluginInteractiveDiscordHandlerContext,
+        "interaction" | "respond" | "channel"
+      > & {
+        interaction: Omit<
+          PluginInteractiveDiscordHandlerContext["interaction"],
+          "data" | "namespace" | "payload"
+        >;
+      }),
+      channel: "discord",
+      interaction: {
+        ...(
+          params.ctx as {
+            interaction: Omit<
+              PluginInteractiveDiscordHandlerContext["interaction"],
+              "data" | "namespace" | "payload"
+            >;
+          }
+        ).interaction,
+        data: params.data,
+        namespace: match.namespace,
+        payload: match.payload,
+      },
+      respond: params.respond as PluginInteractiveDiscordHandlerContext["respond"],
+    });
+  }
+  const resolved = await result;
 
   return {
     matched: true,
-    handled: result?.handled ?? true,
+    handled: resolved?.handled ?? true,
     duplicate: false,
   };
 }

src/plugins/runtime/runtime-channel.ts

@@ -7,7 +7,18 @@ import { monitorDiscordProvider } from "../../../extensions/discord/src/monitor.
 import { probeDiscord } from "../../../extensions/discord/src/probe.js";
 import { resolveDiscordChannelAllowlist } from "../../../extensions/discord/src/resolve-channels.js";
 import { resolveDiscordUserAllowlist } from "../../../extensions/discord/src/resolve-users.js";
-import { sendMessageDiscord, sendPollDiscord } from "../../../extensions/discord/src/send.js";
+import {
+  createThreadDiscord,
+  deleteMessageDiscord,
+  editChannelDiscord,
+  editMessageDiscord,
+  pinMessageDiscord,
+  sendDiscordComponentMessage,
+  sendMessageDiscord,
+  sendPollDiscord,
+  sendTypingDiscord,
+  unpinMessageDiscord,
+} from "../../../extensions/discord/src/send.js";
 import { monitorIMessageProvider } from "../../../extensions/imessage/src/monitor.js";
 import { probeIMessage } from "../../../extensions/imessage/src/probe.js";
 import { sendMessageIMessage } from "../../../extensions/imessage/src/send.js";
@@ -114,6 +125,8 @@ import {
   upsertChannelPairingRequest,
 } from "../../pairing/pairing-store.js";
 import { buildAgentSessionKey, resolveAgentRoute } from "../../routing/resolve-route.js";
+import { createDiscordTypingLease } from "./runtime-discord-typing.js";
+import { createTelegramTypingLease } from "./runtime-telegram-typing.js";
 import { createRuntimeWhatsApp } from "./runtime-whatsapp.js";
 import type { PluginRuntime } from "./types.js";
 
@@ -209,9 +222,33 @@ export function createRuntimeChannel(): PluginRuntime["channel"] {
       probeDiscord,
       resolveChannelAllowlist: resolveDiscordChannelAllowlist,
       resolveUserAllowlist: resolveDiscordUserAllowlist,
+      sendComponentMessage: sendDiscordComponentMessage,
       sendMessageDiscord,
       sendPollDiscord,
       monitorDiscordProvider,
+      typing: {
+        pulse: sendTypingDiscord,
+        start: async ({ channelId, accountId, cfg, intervalMs }) =>
+          await createDiscordTypingLease({
+            channelId,
+            accountId,
+            cfg,
+            intervalMs,
+            pulse: async ({ channelId, accountId, cfg }) =>
+              void (await sendTypingDiscord(channelId, {
+                accountId,
+                cfg,
+              })),
+          }),
+      },
+      conversationActions: {
+        editMessage: editMessageDiscord,
+        deleteMessage: deleteMessageDiscord,
+        pinMessage: pinMessageDiscord,
+        unpinMessage: unpinMessageDiscord,
+        createThread: createThreadDiscord,
+        editChannel: editChannelDiscord,
+      },
     },
     slack: {
       listDirectoryGroupsLive: listSlackDirectoryGroupsLive,

src/plugins/runtime/runtime-discord-typing.test.ts

@@ -0,0 +1,38 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDiscordTypingLease } from "./runtime-discord-typing.js";
+
+describe("createDiscordTypingLease", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("pulses immediately and keeps leases independent", async () => {
+    vi.useFakeTimers();
+    const pulse = vi.fn(async () => undefined);
+
+    const leaseA = await createDiscordTypingLease({
+      channelId: "123",
+      intervalMs: 2_000,
+      pulse,
+    });
+    const leaseB = await createDiscordTypingLease({
+      channelId: "123",
+      intervalMs: 2_000,
+      pulse,
+    });
+
+    expect(pulse).toHaveBeenCalledTimes(2);
+
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect(pulse).toHaveBeenCalledTimes(4);
+
+    leaseA.stop();
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect(pulse).toHaveBeenCalledTimes(5);
+
+    await leaseB.refresh();
+    expect(pulse).toHaveBeenCalledTimes(6);
+
+    leaseB.stop();
+  });
+});

src/plugins/runtime/runtime-discord-typing.ts

@@ -0,0 +1,57 @@
+export type CreateDiscordTypingLeaseParams = {
+  channelId: string;
+  accountId?: string;
+  cfg?: ReturnType<typeof import("../../config/config.js").loadConfig>;
+  intervalMs?: number;
+  pulse: (params: {
+    channelId: string;
+    accountId?: string;
+    cfg?: ReturnType<typeof import("../../config/config.js").loadConfig>;
+  }) => Promise<void>;
+};
+
+const DEFAULT_DISCORD_TYPING_INTERVAL_MS = 8_000;
+
+export async function createDiscordTypingLease(params: CreateDiscordTypingLeaseParams): Promise<{
+  refresh: () => Promise<void>;
+  stop: () => void;
+}> {
+  const intervalMs =
+    typeof params.intervalMs === "number" && Number.isFinite(params.intervalMs)
+      ? Math.max(1_000, Math.floor(params.intervalMs))
+      : DEFAULT_DISCORD_TYPING_INTERVAL_MS;
+
+  let stopped = false;
+  let timer: ReturnType<typeof setInterval> | null = null;
+
+  const pulse = async () => {
+    if (stopped) {
+      return;
+    }
+    await params.pulse({
+      channelId: params.channelId,
+      accountId: params.accountId,
+      cfg: params.cfg,
+    });
+  };
+
+  await pulse();
+
+  timer = setInterval(() => {
+    void pulse();
+  }, intervalMs);
+  timer.unref?.();
+
+  return {
+    refresh: async () => {
+      await pulse();
+    },
+    stop: () => {
+      stopped = true;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    },
+  };
+}

src/plugins/runtime/types-channel.ts

@@ -97,9 +97,30 @@ export type PluginRuntimeChannel = {
     probeDiscord: typeof import("../../../extensions/discord/src/probe.js").probeDiscord;
     resolveChannelAllowlist: typeof import("../../../extensions/discord/src/resolve-channels.js").resolveDiscordChannelAllowlist;
     resolveUserAllowlist: typeof import("../../../extensions/discord/src/resolve-users.js").resolveDiscordUserAllowlist;
+    sendComponentMessage: typeof import("../../../extensions/discord/src/send.js").sendDiscordComponentMessage;
     sendMessageDiscord: typeof import("../../../extensions/discord/src/send.js").sendMessageDiscord;
     sendPollDiscord: typeof import("../../../extensions/discord/src/send.js").sendPollDiscord;
     monitorDiscordProvider: typeof import("../../../extensions/discord/src/monitor.js").monitorDiscordProvider;
+    typing: {
+      pulse: typeof import("../../../extensions/discord/src/send.js").sendTypingDiscord;
+      start: (params: {
+        channelId: string;
+        accountId?: string;
+        cfg?: ReturnType<typeof import("../../config/config.js").loadConfig>;
+        intervalMs?: number;
+      }) => Promise<{
+        refresh: () => Promise<void>;
+        stop: () => void;
+      }>;
+    };
+    conversationActions: {
+      editMessage: typeof import("../../../extensions/discord/src/send.js").editMessageDiscord;
+      deleteMessage: typeof import("../../../extensions/discord/src/send.js").deleteMessageDiscord;
+      pinMessage: typeof import("../../../extensions/discord/src/send.js").pinMessageDiscord;
+      unpinMessage: typeof import("../../../extensions/discord/src/send.js").unpinMessageDiscord;
+      createThread: typeof import("../../../extensions/discord/src/send.js").createThreadDiscord;
+      editChannel: typeof import("../../../extensions/discord/src/send.js").editChannelDiscord;
+    };
   };
   slack: {
     listDirectoryGroupsLive: typeof import("../../../extensions/slack/src/directory-live.js").listSlackDirectoryGroupsLive;

src/plugins/types.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import type { TopLevelComponents } from "@buape/carbon";
 import type { AgentMessage } from "@mariozechner/pi-agent-core";
 import type { Command } from "commander";
 import type {
@@ -305,7 +306,7 @@ export type OpenClawPluginCommandDefinition = {
   handler: PluginCommandHandler;
 };
 
-export type PluginInteractiveChannel = "telegram";
+export type PluginInteractiveChannel = "telegram" | "discord";
 
 export type PluginInteractiveButtons = Array<
   Array<{ text: string; callback_data: string; style?: "danger" | "success" | "primary" }>
@@ -346,14 +347,60 @@ export type PluginInteractiveTelegramHandlerContext = {
   };
 };
 
-export type PluginInteractiveHandlerRegistration = {
-  channel: PluginInteractiveChannel;
+export type PluginInteractiveDiscordHandlerResult = {
+  handled?: boolean;
+} | void;
+
+export type PluginInteractiveDiscordHandlerContext = {
+  channel: "discord";
+  accountId: string;
+  interactionId: string;
+  conversationId: string;
+  parentConversationId?: string;
+  guildId?: string;
+  senderId?: string;
+  senderUsername?: string;
+  auth: {
+    isAuthorizedSender: boolean;
+  };
+  interaction: {
+    kind: "button" | "select" | "modal";
+    data: string;
+    namespace: string;
+    payload: string;
+    messageId?: string;
+    values?: string[];
+    fields?: Array<{ id: string; name: string; values: string[] }>;
+  };
+  respond: {
+    acknowledge: () => Promise<void>;
+    reply: (params: { text: string; ephemeral?: boolean }) => Promise<void>;
+    followUp: (params: { text: string; ephemeral?: boolean }) => Promise<void>;
+    editMessage: (params: { text?: string; components?: TopLevelComponents[] }) => Promise<void>;
+    clearComponents: (params?: { text?: string }) => Promise<void>;
+  };
+};
+
+export type PluginInteractiveTelegramHandlerRegistration = {
+  channel: "telegram";
   namespace: string;
   handler: (
     ctx: PluginInteractiveTelegramHandlerContext,
   ) => Promise<PluginInteractiveTelegramHandlerResult> | PluginInteractiveTelegramHandlerResult;
 };
 
+export type PluginInteractiveDiscordHandlerRegistration = {
+  channel: "discord";
+  namespace: string;
+  handler: (
+    ctx: PluginInteractiveDiscordHandlerContext,
+  ) => Promise<PluginInteractiveDiscordHandlerResult> | PluginInteractiveDiscordHandlerResult;
+};
+
+export type PluginInteractiveHandlerRegistration =
+  | PluginInteractiveTelegramHandlerRegistration
+  | PluginInteractiveDiscordHandlerRegistration;
+
 export type OpenClawPluginHttpRouteAuth = "gateway" | "plugin";
 export type OpenClawPluginHttpRouteMatch = "exact" | "prefix";