@openclaw/discord 2026.3.13 → 2026.5.1-beta.1

package/src/monitor/reply-context.ts

@@ -0,0 +1,64 @@
+import type { Guild, Message, User } from "../internal/discord.js";
+import { resolveTimestampMs } from "./format.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
+
+type DiscordReplyContext = {
+  id: string;
+  channelId: string;
+  sender: string;
+  senderId?: string;
+  senderName?: string;
+  senderTag?: string;
+  memberRoleIds?: string[];
+  body: string;
+  timestamp?: number;
+};
+
+export function resolveReplyContext(
+  message: Message,
+  resolveDiscordMessageText: (message: Message, options?: { includeForwarded?: boolean }) => string,
+): DiscordReplyContext | null {
+  const referenced = message.referencedMessage;
+  if (!referenced?.author) {
+    return null;
+  }
+  const referencedText = resolveDiscordMessageText(referenced, {
+    includeForwarded: true,
+  });
+  if (!referencedText) {
+    return null;
+  }
+  const sender = resolveDiscordSenderIdentity({
+    author: referenced.author,
+    pluralkitInfo: null,
+  });
+  return {
+    id: referenced.id,
+    channelId: referenced.channelId,
+    sender: sender.tag ?? sender.label ?? "unknown",
+    senderId: referenced.author.id,
+    senderName: referenced.author.username ?? undefined,
+    senderTag: sender.tag ?? undefined,
+    memberRoleIds: (() => {
+      const roles = (referenced as { member?: { roles?: string[] } }).member?.roles;
+      return Array.isArray(roles) ? roles.map((roleId) => roleId) : undefined;
+    })(),
+    body: referencedText,
+    timestamp: resolveTimestampMs(referenced.timestamp),
+  };
+}
+
+export function buildDirectLabel(author: User, tagOverride?: string) {
+  const username =
+    tagOverride?.trim() || resolveDiscordSenderIdentity({ author, pluralkitInfo: null }).tag;
+  return `${username ?? "unknown"} user id:${author.id}`;
+}
+
+export function buildGuildLabel(params: {
+  guild?: Guild<true> | Guild;
+  channelName: string;
+  channelId: string;
+}) {
+  const { guild, channelName, channelId } = params;
+  return `${guild?.name ?? "Guild"} #${channelName} channel id:${channelId}`;
+}

package/src/monitor/reply-delivery.test.ts

@@ -0,0 +1,244 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RequestClient } from "../internal/discord.js";
+
+const deliverOutboundPayloadsMock = vi.hoisted(() => vi.fn(async () => []));
+const sendMessageDiscordMock = vi.hoisted(() => vi.fn());
+const sendVoiceMessageDiscordMock = vi.hoisted(() => vi.fn());
+
+vi.mock("openclaw/plugin-sdk/outbound-runtime", async () => {
+  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/outbound-runtime")>(
+    "openclaw/plugin-sdk/outbound-runtime",
+  );
+  return {
+    ...actual,
+    deliverOutboundPayloads: deliverOutboundPayloadsMock,
+  };
+});
+
+vi.mock("../send.js", async () => {
+  const actual = await vi.importActual<typeof import("../send.js")>("../send.js");
+  return {
+    ...actual,
+    sendMessageDiscord: (...args: unknown[]) => sendMessageDiscordMock(...args),
+    sendVoiceMessageDiscord: (...args: unknown[]) => sendVoiceMessageDiscordMock(...args),
+  };
+});
+
+let deliverDiscordReply: typeof import("./reply-delivery.js").deliverDiscordReply;
+
+function firstDeliverParams() {
+  const calls = deliverOutboundPayloadsMock.mock.calls as unknown as Array<
+    [
+      {
+        cfg?: OpenClawConfig;
+        formatting?: unknown;
+        deps?: Record<string, (...args: unknown[]) => Promise<unknown>>;
+      },
+    ]
+  >;
+  const params = calls[0]?.[0];
+  if (!params) {
+    throw new Error("deliverOutboundPayloads was not called");
+  }
+  return params;
+}
+
+describe("deliverDiscordReply", () => {
+  const runtime = {} as RuntimeEnv;
+  const cfg = {
+    channels: { discord: { token: "test-token" } },
+  } as OpenClawConfig;
+
+  beforeAll(async () => {
+    ({ deliverDiscordReply } = await import("./reply-delivery.js"));
+  });
+
+  beforeEach(() => {
+    deliverOutboundPayloadsMock.mockClear();
+    deliverOutboundPayloadsMock.mockResolvedValue([]);
+    sendMessageDiscordMock.mockReset().mockResolvedValue({
+      messageId: "msg-1",
+      channelId: "channel-1",
+    });
+    sendVoiceMessageDiscordMock.mockReset().mockResolvedValue({
+      messageId: "voice-1",
+      channelId: "channel-1",
+    });
+  });
+
+  it("bridges regular replies to shared outbound with Discord package deps", async () => {
+    const rest = {} as RequestClient;
+    const replies = [{ text: "shared path" }];
+
+    await deliverDiscordReply({
+      replies,
+      target: "channel:101",
+      token: "token",
+      accountId: "default",
+      rest,
+      runtime,
+      cfg,
+      textLimit: 2000,
+      replyToId: "reply-1",
+      replyToMode: "all",
+    });
+
+    expect(deliverOutboundPayloadsMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channel: "discord",
+        to: "channel:101",
+        accountId: "default",
+        payloads: replies,
+        replyToId: "reply-1",
+        replyToMode: "all",
+      }),
+    );
+
+    const deps = firstDeliverParams().deps!;
+    await deps.discord("channel:101", "probe", { verbose: false });
+    expect(sendMessageDiscordMock).toHaveBeenCalledWith(
+      "channel:101",
+      "probe",
+      expect.objectContaining({ cfg: firstDeliverParams().cfg, token: "token", rest }),
+    );
+  });
+
+  it("passes resolved Discord formatting options as explicit delivery options", async () => {
+    const baseCfg = {
+      channels: {
+        discord: {
+          token: "test-token",
+          markdown: { tables: "code" },
+          accounts: {
+            default: {
+              token: "account-token",
+              maxLinesPerMessage: 99,
+              streaming: { chunkMode: "length" },
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    await deliverDiscordReply({
+      replies: [{ text: "formatted" }],
+      target: "channel:101",
+      token: "token",
+      accountId: "default",
+      runtime,
+      cfg: baseCfg,
+      textLimit: 1234,
+      maxLinesPerMessage: 7,
+      tableMode: "off",
+      chunkMode: "newline",
+    });
+
+    expect(firstDeliverParams().cfg).toBe(baseCfg);
+    expect(firstDeliverParams().formatting).toEqual({
+      textLimit: 1234,
+      maxLinesPerMessage: 7,
+      tableMode: "off",
+      chunkMode: "newline",
+    });
+  });
+
+  it("passes media roots and explicit off-mode payload reply tags to shared outbound", async () => {
+    const replies = [
+      {
+        text: "explicit reply",
+        replyToId: "reply-explicit-1",
+        replyToTag: true,
+      },
+    ];
+
+    await deliverDiscordReply({
+      replies,
+      target: "channel:202",
+      token: "token",
+      runtime,
+      cfg,
+      textLimit: 2000,
+      replyToMode: "off",
+      mediaLocalRoots: ["/tmp/openclaw-media"],
+    });
+
+    expect(deliverOutboundPayloadsMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payloads: replies,
+        replyToId: undefined,
+        replyToMode: "off",
+        mediaAccess: { localRoots: ["/tmp/openclaw-media"] },
+      }),
+    );
+  });
+
+  it("bridges Discord voice sends through the outbound dependency bag", async () => {
+    await deliverDiscordReply({
+      replies: [{ text: "voice", mediaUrl: "https://example.com/voice.ogg", audioAsVoice: true }],
+      target: "channel:123",
+      token: "token",
+      runtime,
+      cfg,
+      textLimit: 2000,
+      replyToId: "reply-1",
+    });
+
+    const deps = firstDeliverParams().deps!;
+    await deps.discordVoice("channel:123", "https://example.com/voice.ogg", {
+      cfg,
+      replyTo: "reply-1",
+    });
+
+    expect(sendVoiceMessageDiscordMock).toHaveBeenCalledWith(
+      "channel:123",
+      "https://example.com/voice.ogg",
+      expect.objectContaining({ cfg, token: "token", replyTo: "reply-1" }),
+    );
+  });
+
+  it("rewrites bound thread replies to parent target plus thread id and persona", async () => {
+    const threadBindings = {
+      listBySessionKey: vi.fn(() => [
+        {
+          accountId: "default",
+          channelId: "parent-1",
+          threadId: "thread-1",
+          targetSessionKey: "agent:main:subagent:child",
+          agentId: "main",
+          label: "child",
+          webhookId: "wh_1",
+          webhookToken: "tok_1",
+        },
+      ]),
+      touchThread: vi.fn(),
+    };
+
+    await deliverDiscordReply({
+      replies: [{ text: "Hello from subagent" }],
+      target: "channel:thread-1",
+      token: "token",
+      accountId: "default",
+      runtime,
+      cfg,
+      textLimit: 2000,
+      replyToId: "reply-1",
+      sessionKey: "agent:main:subagent:child",
+      threadBindings,
+    });
+
+    expect(deliverOutboundPayloadsMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        to: "channel:parent-1",
+        threadId: "thread-1",
+        replyToId: "reply-1",
+        identity: expect.objectContaining({ name: "🤖 child" }),
+        session: expect.objectContaining({
+          key: "agent:main:subagent:child",
+          agentId: "main",
+        }),
+      }),
+    );
+  });
+});

package/src/monitor/reply-delivery.ts

@@ -0,0 +1,203 @@
+import { resolveAgentAvatar } from "openclaw/plugin-sdk/agent-runtime";
+import type {
+  MarkdownTableMode,
+  OpenClawConfig,
+  ReplyToMode,
+} from "openclaw/plugin-sdk/config-types";
+import type { OutboundMediaAccess } from "openclaw/plugin-sdk/media-runtime";
+import {
+  buildOutboundSessionContext,
+  deliverOutboundPayloads,
+  type OutboundDeliveryFormattingOptions,
+  type OutboundIdentity,
+  type OutboundSendDeps,
+} from "openclaw/plugin-sdk/outbound-runtime";
+import type { ChunkMode } from "openclaw/plugin-sdk/reply-chunking";
+import type { ReplyPayload } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import type { RequestClient } from "../internal/discord.js";
+import { sendMessageDiscord, sendVoiceMessageDiscord } from "../send.js";
+
+export type DiscordThreadBindingLookupRecord = {
+  accountId: string;
+  channelId: string;
+  threadId: string;
+  agentId: string;
+  label?: string;
+  webhookId?: string;
+  webhookToken?: string;
+};
+
+export type DiscordThreadBindingLookup = {
+  listBySessionKey: (targetSessionKey: string) => DiscordThreadBindingLookupRecord[];
+  touchThread?: (params: { threadId: string; at?: number; persist?: boolean }) => unknown;
+};
+
+function resolveTargetChannelId(target: string): string | undefined {
+  if (!target.startsWith("channel:")) {
+    return undefined;
+  }
+  const channelId = target.slice("channel:".length).trim();
+  return channelId || undefined;
+}
+
+function resolveBoundThreadBinding(params: {
+  threadBindings?: DiscordThreadBindingLookup;
+  sessionKey?: string;
+  target: string;
+}): DiscordThreadBindingLookupRecord | undefined {
+  const sessionKey = params.sessionKey?.trim();
+  if (!params.threadBindings || !sessionKey) {
+    return undefined;
+  }
+  const targetChannelId = resolveTargetChannelId(params.target);
+  if (!targetChannelId) {
+    return undefined;
+  }
+  return params.threadBindings
+    .listBySessionKey(sessionKey)
+    .find((entry) => entry.threadId === targetChannelId);
+}
+
+function resolveBindingIdentity(
+  cfg: OpenClawConfig,
+  binding: DiscordThreadBindingLookupRecord | undefined,
+): OutboundIdentity | undefined {
+  if (!binding) {
+    return undefined;
+  }
+  const baseLabel = binding.label?.trim() || binding.agentId;
+  const identity: OutboundIdentity = {
+    name: (`🤖 ${baseLabel}`.trim() || "🤖 agent").slice(0, 80),
+  };
+  try {
+    const avatar = resolveAgentAvatar(cfg, binding.agentId);
+    if (avatar.kind === "remote") {
+      identity.avatarUrl = avatar.url;
+    }
+  } catch {
+    // Avatar is cosmetic; delivery should not depend on local identity config.
+  }
+  return identity;
+}
+
+function createDiscordDeliveryDeps(params: {
+  cfg: OpenClawConfig;
+  token: string;
+  rest?: RequestClient;
+}): OutboundSendDeps {
+  return {
+    discord: (to: string, text: string, opts?: Parameters<typeof sendMessageDiscord>[2]) =>
+      sendMessageDiscord(to, text, {
+        ...opts,
+        cfg: opts?.cfg ?? params.cfg,
+        token: params.token,
+        rest: params.rest,
+      }),
+    discordVoice: (
+      to: string,
+      audioPath: string,
+      opts?: Parameters<typeof sendVoiceMessageDiscord>[2],
+    ) =>
+      sendVoiceMessageDiscord(to, audioPath, {
+        ...opts,
+        cfg: opts?.cfg ?? params.cfg,
+        token: params.token,
+        rest: params.rest,
+      }),
+  };
+}
+
+type DiscordDeliveryOptions = {
+  to: string;
+  threadId?: string;
+  agentId?: string;
+  identity?: OutboundIdentity;
+  mediaAccess?: OutboundMediaAccess;
+  replyToMode: ReplyToMode;
+  formatting: OutboundDeliveryFormattingOptions;
+};
+
+function resolveDiscordDeliveryOptions(params: {
+  cfg: OpenClawConfig;
+  target: string;
+  sessionKey?: string;
+  threadBindings?: DiscordThreadBindingLookup;
+  textLimit: number;
+  maxLinesPerMessage?: number;
+  tableMode?: MarkdownTableMode;
+  chunkMode?: ChunkMode;
+  replyToMode?: ReplyToMode;
+  mediaLocalRoots?: readonly string[];
+}): DiscordDeliveryOptions {
+  const binding = resolveBoundThreadBinding({
+    threadBindings: params.threadBindings,
+    sessionKey: params.sessionKey,
+    target: params.target,
+  });
+  return {
+    to: binding ? `channel:${binding.channelId}` : params.target,
+    threadId: binding?.threadId,
+    agentId: binding?.agentId,
+    identity: resolveBindingIdentity(params.cfg, binding),
+    mediaAccess: params.mediaLocalRoots?.length
+      ? { localRoots: params.mediaLocalRoots }
+      : undefined,
+    replyToMode: params.replyToMode ?? "all",
+    formatting: {
+      textLimit: params.textLimit,
+      maxLinesPerMessage: params.maxLinesPerMessage,
+      tableMode: params.tableMode,
+      chunkMode: params.chunkMode,
+    },
+  };
+}
+
+export async function deliverDiscordReply(params: {
+  cfg: OpenClawConfig;
+  replies: ReplyPayload[];
+  target: string;
+  token: string;
+  accountId?: string;
+  rest?: RequestClient;
+  runtime: RuntimeEnv;
+  textLimit: number;
+  maxLinesPerMessage?: number;
+  replyToId?: string;
+  replyToMode?: ReplyToMode;
+  tableMode?: MarkdownTableMode;
+  chunkMode?: ChunkMode;
+  sessionKey?: string;
+  threadBindings?: DiscordThreadBindingLookup;
+  mediaLocalRoots?: readonly string[];
+}) {
+  void params.runtime;
+
+  const delivery = resolveDiscordDeliveryOptions(params);
+
+  await deliverOutboundPayloads({
+    cfg: params.cfg,
+    channel: "discord",
+    to: delivery.to,
+    accountId: params.accountId,
+    payloads: params.replies,
+    replyToId: normalizeOptionalString(params.replyToId),
+    replyToMode: delivery.replyToMode,
+    formatting: delivery.formatting,
+    threadId: delivery.threadId,
+    identity: delivery.identity,
+    deps: createDiscordDeliveryDeps({
+      cfg: params.cfg,
+      token: params.token,
+      rest: params.rest,
+    }),
+    mediaAccess: delivery.mediaAccess,
+    session: buildOutboundSessionContext({
+      cfg: params.cfg,
+      sessionKey: params.sessionKey,
+      agentId: delivery.agentId,
+      requesterAccountId: params.accountId,
+    }),
+  });
+}

package/src/monitor/rest-fetch.ts

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
+import {
+  captureHttpExchange,
+  resolveEffectiveDebugProxyUrl,
+} from "openclaw/plugin-sdk/proxy-capture";
+import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
+import { ProxyAgent, fetch as undiciFetch } from "undici";
+import { withValidatedDiscordProxy } from "../proxy-fetch.js";
+
+export function resolveDiscordRestFetch(
+  proxyUrl: string | undefined,
+  runtime: RuntimeEnv,
+): typeof fetch {
+  const effectiveProxyUrl = resolveEffectiveDebugProxyUrl(proxyUrl);
+  const fetcher = withValidatedDiscordProxy(effectiveProxyUrl, runtime, (proxy) => {
+    const agent = new ProxyAgent(proxy);
+    return wrapFetchWithAbortSignal(((input: RequestInfo | URL, init?: RequestInit) =>
+      (
+        undiciFetch(input as string | URL, {
+          ...(init as Record<string, unknown>),
+          dispatcher: agent,
+        }) as unknown as Promise<Response>
+      ).then((response) => {
+        captureHttpExchange({
+          url: resolveRequestUrl(input),
+          method: init?.method ?? "GET",
+          requestHeaders: init?.headers as Headers | Record<string, string> | undefined,
+          requestBody: (init as RequestInit & { body?: BodyInit | null })?.body ?? null,
+          response,
+          flowId: randomUUID(),
+          meta: { subsystem: "discord-rest" },
+        });
+        return response;
+      })) as typeof fetch);
+  });
+  if (!fetcher) {
+    return fetch;
+  }
+  runtime.log?.("discord: rest proxy enabled");
+  return fetcher;
+}