@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/monitor/native-command-context.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import { buildDiscordNativeCommandContext } from "./native-command-context.js";
+
+describe("buildDiscordNativeCommandContext", () => {
+  it("builds direct-message slash command context", () => {
+    const ctx = buildDiscordNativeCommandContext({
+      prompt: "/status",
+      commandArgs: {},
+      sessionKey: "agent:codex:discord:slash:user-1",
+      commandTargetSessionKey: "agent:codex:discord:direct:user-1",
+      accountId: "default",
+      interactionId: "interaction-1",
+      channelId: "dm-1",
+      commandAuthorized: true,
+      isDirectMessage: true,
+      isGroupDm: false,
+      isGuild: false,
+      isThreadChannel: false,
+      user: {
+        id: "user-1",
+        username: "tester",
+        globalName: "Tester",
+      },
+      sender: {
+        id: "user-1",
+        tag: "tester#0001",
+      },
+      timestampMs: 123,
+    });
+
+    expect(ctx.From).toBe("discord:user-1");
+    expect(ctx.To).toBe("slash:user-1");
+    expect(ctx.ChatType).toBe("direct");
+    expect(ctx.ConversationLabel).toBe("Tester");
+    expect(ctx.SessionKey).toBe("agent:codex:discord:slash:user-1");
+    expect(ctx.CommandTargetSessionKey).toBe("agent:codex:discord:direct:user-1");
+    expect(ctx.OriginatingTo).toBe("user:user-1");
+    expect(ctx.UntrustedContext).toBeUndefined();
+    expect(ctx.GroupSystemPrompt).toBeUndefined();
+    expect(ctx.Timestamp).toBe(123);
+  });
+
+  it("builds guild slash command context with owner allowlist and channel metadata", () => {
+    const ctx = buildDiscordNativeCommandContext({
+      prompt: "/status",
+      commandArgs: { values: { model: "gpt-5.2" } },
+      sessionKey: "agent:codex:discord:slash:user-1",
+      commandTargetSessionKey: "agent:codex:discord:channel:chan-1",
+      accountId: "default",
+      interactionId: "interaction-1",
+      channelId: "chan-1",
+      threadParentId: "parent-1",
+      memberRoleIds: ["admin"],
+      guildName: "Ops",
+      channelTopic: "Production alerts only",
+      channelConfig: {
+        allowed: true,
+        users: ["discord:user-1"],
+        systemPrompt: "Use the runbook.",
+      },
+      guildInfo: {
+        id: "guild-1",
+      },
+      allowNameMatching: false,
+      commandAuthorized: true,
+      isDirectMessage: false,
+      isGroupDm: false,
+      isGuild: true,
+      isThreadChannel: true,
+      user: {
+        id: "user-1",
+        username: "tester",
+      },
+      sender: {
+        id: "user-1",
+        name: "tester",
+        tag: "tester#0001",
+      },
+      timestampMs: 456,
+    });
+
+    expect(ctx.From).toBe("discord:channel:chan-1");
+    expect(ctx.ChatType).toBe("channel");
+    expect(ctx.ConversationLabel).toBe("chan-1");
+    expect(ctx.GroupSubject).toBe("Ops");
+    expect(ctx.GroupSpace).toBe("guild-1");
+    expect(ctx.MemberRoleIds).toEqual(["admin"]);
+    expect(ctx.GroupSystemPrompt).toBe("Use the runbook.");
+    expect(ctx.OwnerAllowFrom).toEqual(["user-1"]);
+    expect(ctx.MessageThreadId).toBe("chan-1");
+    expect(ctx.ThreadParentId).toBe("parent-1");
+    expect(ctx.OriginatingTo).toBe("channel:chan-1");
+    expect(ctx.UntrustedContext).toEqual([
+      expect.stringContaining("Discord channel topic:\nProduction alerts only"),
+    ]);
+    expect(ctx.Timestamp).toBe(456);
+  });
+});

package/src/monitor/native-command-context.ts

@@ -0,0 +1,103 @@
+import type { CommandArgs } from "openclaw/plugin-sdk/command-auth";
+import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import { resolveDiscordConversationIdentity } from "../conversation-identity.js";
+import { type DiscordChannelConfigResolved, type DiscordGuildEntryResolved } from "./allow-list.js";
+import { buildDiscordInboundAccessContext } from "./inbound-context.js";
+
+type BuildDiscordNativeCommandContextParams = {
+  prompt: string;
+  commandArgs: CommandArgs;
+  sessionKey: string;
+  commandTargetSessionKey: string;
+  accountId?: string | null;
+  interactionId: string;
+  channelId: string;
+  threadParentId?: string;
+  memberRoleIds?: string[];
+  guildId?: string;
+  guildName?: string;
+  channelTopic?: string;
+  channelConfig?: DiscordChannelConfigResolved | null;
+  guildInfo?: DiscordGuildEntryResolved | null;
+  allowNameMatching?: boolean;
+  commandAuthorized: boolean;
+  isDirectMessage: boolean;
+  isGroupDm: boolean;
+  isGuild: boolean;
+  isThreadChannel: boolean;
+  user: {
+    id: string;
+    username: string;
+    globalName?: string | null;
+  };
+  sender: {
+    id: string;
+    name?: string;
+    tag?: string;
+  };
+  timestampMs?: number;
+};
+
+export function buildDiscordNativeCommandContext(params: BuildDiscordNativeCommandContextParams) {
+  const conversationLabel = params.isDirectMessage
+    ? (params.user.globalName ?? params.user.username)
+    : params.channelId;
+  const { groupSystemPrompt, ownerAllowFrom, untrustedContext } = buildDiscordInboundAccessContext({
+    channelConfig: params.channelConfig,
+    guildInfo: params.guildInfo,
+    sender: params.sender,
+    allowNameMatching: params.allowNameMatching,
+    isGuild: params.isGuild,
+    channelTopic: params.channelTopic,
+  });
+
+  return finalizeInboundContext({
+    Body: params.prompt,
+    BodyForAgent: params.prompt,
+    RawBody: params.prompt,
+    CommandBody: params.prompt,
+    CommandArgs: params.commandArgs,
+    From: params.isDirectMessage
+      ? `discord:${params.user.id}`
+      : params.isGroupDm
+        ? `discord:group:${params.channelId}`
+        : `discord:channel:${params.channelId}`,
+    To: `slash:${params.user.id}`,
+    SessionKey: params.sessionKey,
+    CommandTargetSessionKey: params.commandTargetSessionKey,
+    AccountId: params.accountId ?? undefined,
+    ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+    ConversationLabel: conversationLabel,
+    GroupSubject: params.isGuild ? params.guildName : undefined,
+    GroupSpace: params.isGuild
+      ? (params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId)
+      : undefined,
+    MemberRoleIds: params.memberRoleIds,
+    GroupSystemPrompt: groupSystemPrompt,
+    UntrustedContext: untrustedContext,
+    OwnerAllowFrom: ownerAllowFrom,
+    SenderName: params.user.globalName ?? params.user.username,
+    SenderId: params.user.id,
+    SenderUsername: params.user.username,
+    SenderTag: params.sender.tag,
+    Provider: "discord" as const,
+    Surface: "discord" as const,
+    WasMentioned: true,
+    MessageSid: params.interactionId,
+    MessageThreadId: params.isThreadChannel ? params.channelId : undefined,
+    Timestamp: params.timestampMs ?? Date.now(),
+    CommandAuthorized: params.commandAuthorized,
+    CommandSource: "native" as const,
+    // Native slash contexts use To=slash:<user> for interaction routing.
+    // For follow-up delivery (for example subagent completion announces),
+    // preserve the real Discord target separately.
+    OriginatingChannel: "discord" as const,
+    OriginatingTo:
+      resolveDiscordConversationIdentity({
+        isDirectMessage: params.isDirectMessage,
+        userId: params.user.id,
+        channelId: params.channelId,
+      }) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`),
+    ThreadParentId: params.isThreadChannel ? params.threadParentId : undefined,
+  });
+}

package/src/monitor/native-command-dispatch.ts

@@ -0,0 +1,35 @@
+import type { ChatCommandDefinition, CommandArgs } from "openclaw/plugin-sdk/command-auth";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import type { ResolvedAgentRoute } from "openclaw/plugin-sdk/routing";
+import type {
+  ButtonInteraction,
+  CommandInteraction,
+  StringSelectMenuInteraction,
+} from "../internal/discord.js";
+import type { ThreadBindingManager } from "./thread-bindings.js";
+
+type DiscordConfig = NonNullable<OpenClawConfig["channels"]>["discord"];
+
+export type DispatchDiscordCommandInteractionParams = {
+  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
+  prompt: string;
+  command: ChatCommandDefinition;
+  commandArgs?: CommandArgs;
+  cfg: OpenClawConfig;
+  discordConfig: DiscordConfig;
+  accountId: string;
+  sessionPrefix: string;
+  preferFollowUp: boolean;
+  threadBindings: ThreadBindingManager;
+  responseEphemeral?: boolean;
+  suppressReplies?: boolean;
+};
+
+export type DispatchDiscordCommandInteractionResult = {
+  accepted: boolean;
+  effectiveRoute?: ResolvedAgentRoute;
+};
+
+export type DispatchDiscordCommandInteraction = (
+  params: DispatchDiscordCommandInteractionParams,
+) => Promise<DispatchDiscordCommandInteractionResult>;

package/src/monitor/native-command-model-picker-apply.ts

@@ -0,0 +1,177 @@
+import type { ChatCommandDefinition, CommandArgs } from "openclaw/plugin-sdk/command-auth";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { applyModelOverrideToSessionEntry } from "openclaw/plugin-sdk/model-session-runtime";
+import type { ResolvedAgentRoute } from "openclaw/plugin-sdk/routing";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { resolveStorePath, updateSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
+import { withTimeout } from "openclaw/plugin-sdk/text-runtime";
+import type { ButtonInteraction, StringSelectMenuInteraction } from "../internal/discord.js";
+import {
+  recordDiscordModelPickerRecentModel,
+  type DiscordModelPickerPreferenceScope,
+} from "./model-picker-preferences.js";
+import type { DispatchDiscordCommandInteraction } from "./native-command-dispatch.js";
+import type { ThreadBindingManager } from "./thread-bindings.js";
+
+type DiscordConfig = NonNullable<OpenClawConfig["channels"]>["discord"];
+
+type DiscordModelPickerSelectionCommand = {
+  prompt: string;
+  command: ChatCommandDefinition;
+  args?: CommandArgs;
+};
+
+type DiscordModelPickerApplyResult =
+  | { status: "success"; effectiveModelRef: string; noticeMessage: string }
+  | { status: "mismatch"; effectiveModelRef: string; noticeMessage: string }
+  | { status: "rejected"; noticeMessage: string }
+  | { status: "timeout"; noticeMessage: string }
+  | { status: "failed"; noticeMessage: string };
+
+async function persistDiscordModelPickerOverride(params: {
+  cfg: OpenClawConfig;
+  route: ResolvedAgentRoute;
+  provider: string;
+  model: string;
+  isDefault: boolean;
+}): Promise<boolean> {
+  const storePath = resolveStorePath(params.cfg.session?.store, {
+    agentId: params.route.agentId,
+  });
+  let persisted = false;
+  await updateSessionStore(storePath, (store) => {
+    const entry = store[params.route.sessionKey];
+    if (!entry) {
+      return;
+    }
+    persisted =
+      applyModelOverrideToSessionEntry({
+        entry,
+        selection: {
+          provider: params.provider,
+          model: params.model,
+          isDefault: params.isDefault,
+        },
+        markLiveSwitchPending: true,
+      }).updated || persisted;
+  });
+  return persisted;
+}
+
+export async function applyDiscordModelPickerSelection(params: {
+  interaction: ButtonInteraction | StringSelectMenuInteraction;
+  selectionCommand: DiscordModelPickerSelectionCommand;
+  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
+  cfg: OpenClawConfig;
+  discordConfig: DiscordConfig;
+  accountId: string;
+  sessionPrefix: string;
+  threadBindings: ThreadBindingManager;
+  route: ResolvedAgentRoute;
+  resolvedModelRef: string;
+  selectedProvider: string;
+  selectedModel: string;
+  defaultProvider: string;
+  defaultModel: string;
+  preferenceScope: DiscordModelPickerPreferenceScope;
+  settleMs: number;
+  resolveCurrentModel: (route: ResolvedAgentRoute) => string;
+}): Promise<DiscordModelPickerApplyResult> {
+  try {
+    const dispatchResult = await withTimeout(
+      params.dispatchCommandInteraction({
+        interaction: params.interaction,
+        prompt: params.selectionCommand.prompt,
+        command: params.selectionCommand.command,
+        commandArgs: params.selectionCommand.args,
+        cfg: params.cfg,
+        discordConfig: params.discordConfig,
+        accountId: params.accountId,
+        sessionPrefix: params.sessionPrefix,
+        preferFollowUp: true,
+        threadBindings: params.threadBindings,
+        suppressReplies: true,
+      }),
+      12000,
+    );
+    if (!dispatchResult.accepted) {
+      return {
+        status: "rejected",
+        noticeMessage: `❌ Failed to apply ${params.resolvedModelRef}. Try /model ${params.resolvedModelRef} directly.`,
+      };
+    }
+
+    const fallbackRoute = dispatchResult.effectiveRoute ?? params.route;
+    if (params.settleMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, params.settleMs));
+    }
+
+    let effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
+    let persisted = effectiveModelRef === params.resolvedModelRef;
+
+    if (!persisted) {
+      logVerbose(
+        `discord: model picker override mismatch — expected ${params.resolvedModelRef} but read ${effectiveModelRef} from session key ${fallbackRoute.sessionKey}; attempting direct session override persist`,
+      );
+      try {
+        const directlyPersisted = await persistDiscordModelPickerOverride({
+          cfg: params.cfg,
+          route: fallbackRoute,
+          provider: params.selectedProvider,
+          model: params.selectedModel,
+          isDefault:
+            params.selectedProvider === params.defaultProvider &&
+            params.selectedModel === params.defaultModel,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
+        persisted = effectiveModelRef === params.resolvedModelRef;
+        if (!persisted) {
+          logVerbose(
+            `discord: direct session override persist failed — expected ${params.resolvedModelRef} but read ${effectiveModelRef} from session key ${fallbackRoute.sessionKey}`,
+          );
+        } else if (!directlyPersisted) {
+          logVerbose(
+            `discord: direct session override persist became a no-op because ${params.resolvedModelRef} was already present on re-read for session key ${fallbackRoute.sessionKey}`,
+          );
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logVerbose(
+          `discord: direct session override persist threw for session key ${fallbackRoute.sessionKey}: ${message}`,
+        );
+      }
+    }
+
+    if (persisted) {
+      await recordDiscordModelPickerRecentModel({
+        scope: params.preferenceScope,
+        modelRef: params.resolvedModelRef,
+        limit: 5,
+      }).catch(() => undefined);
+    }
+
+    return persisted
+      ? {
+          status: "success",
+          effectiveModelRef,
+          noticeMessage: `✅ Model set to ${params.resolvedModelRef}.`,
+        }
+      : {
+          status: "mismatch",
+          effectiveModelRef,
+          noticeMessage: `⚠️ Tried to set ${params.resolvedModelRef}, but current model is ${effectiveModelRef}.`,
+        };
+  } catch (error) {
+    if (error instanceof Error && error.message === "timeout") {
+      return {
+        status: "timeout",
+        noticeMessage: `⏳ Model change to ${params.resolvedModelRef} is still processing. Check /status in a few seconds.`,
+      };
+    }
+    return {
+      status: "failed",
+      noticeMessage: `❌ Failed to apply ${params.resolvedModelRef}. Try /model ${params.resolvedModelRef} directly.`,
+    };
+  }
+}