@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

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

@@ -1,368 +0,0 @@
-import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
-import {
-  resolveStoredModelOverride,
-  serializeCommandArgs,
-  type ChatCommandDefinition,
-  type 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 { loadSessionStore, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-import {
-  normalizeLowercaseStringOrEmpty,
-  normalizeOptionalString,
-} from "openclaw/plugin-sdk/text-runtime";
-import {
-  Container,
-  TextDisplay,
-  type AutocompleteInteraction,
-  type ButtonInteraction,
-  type CommandInteraction,
-  type StringSelectMenuInteraction,
-} from "../internal/discord.js";
-import {
-  readDiscordModelPickerRecentModels,
-  type DiscordModelPickerPreferenceScope,
-} from "./model-picker-preferences.js";
-import {
-  loadDiscordModelPickerData,
-  renderDiscordModelPickerModelsView,
-  toDiscordModelPickerMessagePayload,
-  type DiscordModelPickerCommandContext,
-} from "./model-picker.js";
-import { resolveDiscordNativeInteractionRouteState } from "./native-command-route.js";
-import type { SafeDiscordInteractionCall } from "./native-command-ui.types.js";
-import { resolveDiscordNativeInteractionChannelContext } from "./native-interaction-channel-context.js";
-import type { ThreadBindingManager } from "./thread-bindings.js";
-
-type DiscordNativeChoiceInteraction =
-  | AutocompleteInteraction
-  | CommandInteraction
-  | ButtonInteraction
-  | StringSelectMenuInteraction;
-
-function resolveDiscordModelPickerCommandContext(
-  command: ChatCommandDefinition,
-): DiscordModelPickerCommandContext | null {
-  const normalized = normalizeLowercaseStringOrEmpty(command.nativeName ?? command.key);
-  if (normalized === "model" || normalized === "models") {
-    return normalized;
-  }
-  return null;
-}
-
-function resolveCommandArgStringValue(args: CommandArgs | undefined, key: string): string {
-  const value = args?.values?.[key];
-  if (typeof value !== "string") {
-    return "";
-  }
-  return value.trim();
-}
-
-export function shouldOpenDiscordModelPickerFromCommand(params: {
-  command: ChatCommandDefinition;
-  commandArgs?: CommandArgs;
-}): DiscordModelPickerCommandContext | null {
-  const context = resolveDiscordModelPickerCommandContext(params.command);
-  if (!context) {
-    return null;
-  }
-
-  const serializedArgs =
-    normalizeOptionalString(serializeCommandArgs(params.command, params.commandArgs)) ?? "";
-  if (context === "model") {
-    const modelValue = resolveCommandArgStringValue(params.commandArgs, "model");
-    return !modelValue && !serializedArgs ? context : null;
-  }
-
-  return serializedArgs ? null : context;
-}
-
-function buildDiscordModelPickerCurrentModel(
-  defaultProvider: string,
-  defaultModel: string,
-): string {
-  return `${defaultProvider}/${defaultModel}`;
-}
-
-function resolveConfiguredAgentRuntimeId(value: {
-  agentRuntime?: { id?: unknown };
-}): string | undefined {
-  return normalizeOptionalString(value.agentRuntime?.id);
-}
-
-export function buildDiscordModelPickerAllowedModelRefs(
-  data: Awaited<ReturnType<typeof loadDiscordModelPickerData>>,
-): Set<string> {
-  const out = new Set<string>();
-  for (const provider of data.providers) {
-    const models = data.byProvider.get(provider);
-    if (!models) {
-      continue;
-    }
-    for (const model of models) {
-      out.add(`${provider}/${model}`);
-    }
-  }
-  return out;
-}
-
-export function resolveDiscordModelPickerPreferenceScope(params: {
-  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
-  accountId: string;
-  userId: string;
-}): DiscordModelPickerPreferenceScope {
-  return {
-    accountId: params.accountId,
-    guildId: params.interaction.guild?.id ?? undefined,
-    userId: params.userId,
-  };
-}
-
-export function buildDiscordModelPickerNoticePayload(message: string): { components: Container[] } {
-  return {
-    components: [new Container([new TextDisplay(message)])],
-  };
-}
-
-async function resolveDiscordModelPickerRouteState(params: {
-  interaction:
-    | CommandInteraction
-    | ButtonInteraction
-    | StringSelectMenuInteraction
-    | AutocompleteInteraction;
-  cfg: OpenClawConfig;
-  accountId: string;
-  threadBindings: ThreadBindingManager;
-  enforceConfiguredBindingReadiness?: boolean;
-}) {
-  const { interaction, cfg, accountId } = params;
-  const { isDirectMessage, isGroupDm, isThreadChannel, rawChannelId, threadParentId } =
-    await resolveDiscordNativeInteractionChannelContext({
-      channel: interaction.channel,
-      client: interaction.client,
-      hasGuild: Boolean(interaction.guild),
-      channelIdFallback: "unknown",
-    });
-  const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
-    ? interaction.rawData.member.roles.map((roleId: string) => roleId)
-    : [];
-
-  const threadBinding = isThreadChannel
-    ? params.threadBindings.getByThreadId(rawChannelId)
-    : undefined;
-  return await resolveDiscordNativeInteractionRouteState({
-    cfg,
-    accountId,
-    guildId: interaction.guild?.id ?? undefined,
-    memberRoleIds,
-    isDirectMessage,
-    isGroupDm,
-    directUserId: interaction.user?.id ?? rawChannelId,
-    conversationId: rawChannelId,
-    parentConversationId: threadParentId,
-    threadBinding,
-    enforceConfiguredBindingReadiness: params.enforceConfiguredBindingReadiness,
-  });
-}
-
-export async function resolveDiscordModelPickerRoute(params: {
-  interaction:
-    | CommandInteraction
-    | ButtonInteraction
-    | StringSelectMenuInteraction
-    | AutocompleteInteraction;
-  cfg: OpenClawConfig;
-  accountId: string;
-  threadBindings: ThreadBindingManager;
-}) {
-  const resolved = await resolveDiscordModelPickerRouteState(params);
-  return resolved.effectiveRoute;
-}
-
-export async function resolveDiscordNativeChoiceContext(params: {
-  interaction: DiscordNativeChoiceInteraction;
-  cfg: OpenClawConfig;
-  accountId: string;
-  threadBindings: ThreadBindingManager;
-}): Promise<{ provider?: string; model?: string } | null> {
-  try {
-    const resolved = await resolveDiscordModelPickerRouteState({
-      interaction: params.interaction,
-      cfg: params.cfg,
-      accountId: params.accountId,
-      threadBindings: params.threadBindings,
-      enforceConfiguredBindingReadiness: true,
-    });
-    if (resolved.bindingReadiness && !resolved.bindingReadiness.ok) {
-      return null;
-    }
-    const route = resolved.effectiveRoute;
-    const fallback = resolveDefaultModelForAgent({
-      cfg: params.cfg,
-      agentId: route.agentId,
-    });
-    const storePath = resolveStorePath(params.cfg.session?.store, {
-      agentId: route.agentId,
-    });
-    const sessionStore = loadSessionStore(storePath);
-    const sessionEntry = sessionStore[route.sessionKey];
-    const override = resolveStoredModelOverride({
-      sessionEntry,
-      sessionStore,
-      sessionKey: route.sessionKey,
-      defaultProvider: fallback.provider,
-    });
-    if (!override?.model) {
-      return {
-        provider: fallback.provider,
-        model: fallback.model,
-      };
-    }
-    return {
-      provider: override.provider || fallback.provider,
-      model: override.model,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export function resolveDiscordModelPickerCurrentModel(params: {
-  cfg: OpenClawConfig;
-  route: ResolvedAgentRoute;
-  data: Awaited<ReturnType<typeof loadDiscordModelPickerData>>;
-}): string {
-  const fallback = buildDiscordModelPickerCurrentModel(
-    params.data.resolvedDefault.provider,
-    params.data.resolvedDefault.model,
-  );
-  try {
-    const storePath = resolveStorePath(params.cfg.session?.store, {
-      agentId: params.route.agentId,
-    });
-    const sessionStore = loadSessionStore(storePath, { skipCache: true });
-    const sessionEntry = sessionStore[params.route.sessionKey];
-    const override = resolveStoredModelOverride({
-      sessionEntry,
-      sessionStore,
-      sessionKey: params.route.sessionKey,
-      defaultProvider: params.data.resolvedDefault.provider,
-    });
-    if (!override?.model) {
-      return fallback;
-    }
-    const provider = (override.provider || params.data.resolvedDefault.provider).trim();
-    if (!provider) {
-      return fallback;
-    }
-    return `${provider}/${override.model}`;
-  } catch {
-    return fallback;
-  }
-}
-
-export function resolveDiscordModelPickerCurrentRuntime(params: {
-  cfg: OpenClawConfig;
-  route: ResolvedAgentRoute;
-}): string {
-  try {
-    const storePath = resolveStorePath(params.cfg.session?.store, {
-      agentId: params.route.agentId,
-    });
-    const sessionStore = loadSessionStore(storePath, { skipCache: true });
-    const sessionRuntime = normalizeOptionalString(
-      sessionStore[params.route.sessionKey]?.agentRuntimeOverride,
-    );
-    if (sessionRuntime) {
-      return sessionRuntime;
-    }
-  } catch {
-    // Fall through to configured defaults when the session store is unavailable.
-  }
-
-  const agentRuntime = resolveConfiguredAgentRuntimeId(
-    params.cfg.agents?.list?.find(
-      (entry) => normalizeOptionalString(entry.id) === params.route.agentId,
-    ) ?? {},
-  );
-  if (agentRuntime) {
-    return agentRuntime;
-  }
-  return resolveConfiguredAgentRuntimeId(params.cfg.agents?.defaults ?? {}) ?? "auto";
-}
-
-export async function replyWithDiscordModelPickerProviders(params: {
-  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
-  cfg: OpenClawConfig;
-  command: DiscordModelPickerCommandContext;
-  userId: string;
-  accountId: string;
-  threadBindings: ThreadBindingManager;
-  preferFollowUp: boolean;
-  safeInteractionCall: SafeDiscordInteractionCall;
-}) {
-  const route = await resolveDiscordModelPickerRoute({
-    interaction: params.interaction,
-    cfg: params.cfg,
-    accountId: params.accountId,
-    threadBindings: params.threadBindings,
-  });
-  const data = await loadDiscordModelPickerData(params.cfg, route.agentId);
-  const currentModel = resolveDiscordModelPickerCurrentModel({
-    cfg: params.cfg,
-    route,
-    data,
-  });
-  const currentRuntime = resolveDiscordModelPickerCurrentRuntime({
-    cfg: params.cfg,
-    route,
-  });
-  const quickModels = await readDiscordModelPickerRecentModels({
-    scope: resolveDiscordModelPickerPreferenceScope({
-      interaction: params.interaction,
-      accountId: params.accountId,
-      userId: params.userId,
-    }),
-    allowedModelRefs: buildDiscordModelPickerAllowedModelRefs(data),
-    limit: 5,
-  });
-
-  const rendered = renderDiscordModelPickerModelsView({
-    command: params.command,
-    userId: params.userId,
-    data,
-    provider: splitDiscordModelRef(currentModel ?? "")?.provider ?? data.resolvedDefault.provider,
-    page: 1,
-    providerPage: 1,
-    currentModel,
-    currentRuntime,
-    quickModels,
-  });
-  const payload = {
-    ...toDiscordModelPickerMessagePayload(rendered),
-    ephemeral: true,
-  };
-
-  await params.safeInteractionCall("model picker reply", async () => {
-    if (params.preferFollowUp) {
-      await params.interaction.followUp(payload);
-      return;
-    }
-    await params.interaction.reply(payload);
-  });
-}
-
-export function splitDiscordModelRef(modelRef: string): { provider: string; model: string } | null {
-  const trimmed = modelRef.trim();
-  const slashIndex = trimmed.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
-    return null;
-  }
-  const provider = trimmed.slice(0, slashIndex).trim();
-  const model = trimmed.slice(slashIndex + 1).trim();
-  if (!provider || !model) {
-    return null;
-  }
-  return { provider, model };
-}

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

@@ -1,68 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { Container, TextDisplay } from "../internal/discord.js";
-import {
-  deliverDiscordInteractionReply,
-  hasRenderableReplyPayload,
-} from "./native-command-reply.js";
-
-function createInteraction() {
-  return {
-    reply: vi.fn().mockResolvedValue({ ok: true }),
-    followUp: vi.fn().mockResolvedValue({ ok: true }),
-  };
-}
-
-describe("deliverDiscordInteractionReply", () => {
-  it("sends component-only native command replies as follow-ups", async () => {
-    const interaction = createInteraction();
-    const components = [new Container([new TextDisplay("Pick a model")])];
-    const payload = {
-      channelData: {
-        discord: {
-          components,
-        },
-      },
-    };
-
-    expect(hasRenderableReplyPayload(payload)).toBe(true);
-
-    await deliverDiscordInteractionReply({
-      interaction: interaction as never,
-      payload,
-      textLimit: 2000,
-      preferFollowUp: true,
-      responseEphemeral: true,
-      chunkMode: "length",
-    });
-
-    expect(interaction.followUp).toHaveBeenCalledWith({
-      components,
-      ephemeral: true,
-    });
-    expect(interaction.reply).not.toHaveBeenCalled();
-  });
-
-  it("sends component-only native command replies through the initial reply when not deferred", async () => {
-    const interaction = createInteraction();
-    const components = [new Container([new TextDisplay("Choose an action")])];
-
-    await deliverDiscordInteractionReply({
-      interaction: interaction as never,
-      payload: {
-        channelData: {
-          discord: {
-            components,
-          },
-        },
-      },
-      textLimit: 2000,
-      preferFollowUp: false,
-      chunkMode: "length",
-    });
-
-    expect(interaction.reply).toHaveBeenCalledWith({
-      components,
-    });
-    expect(interaction.followUp).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,185 +0,0 @@
-import type { ReplyPayload } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import {
-  resolveSendableOutboundReplyParts,
-  resolveTextChunksWithFallback,
-} from "openclaw/plugin-sdk/reply-payload";
-import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import { chunkDiscordTextWithMode } from "../chunk.js";
-import type {
-  ButtonInteraction,
-  CommandInteraction,
-  StringSelectMenuInteraction,
-  TopLevelComponents,
-} from "../internal/discord.js";
-
-export const DISCORD_EMPTY_VISIBLE_REPLY_WARNING = "⚠️ Command produced no visible reply.";
-
-export function isDiscordUnknownInteraction(error: unknown): boolean {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const err = error as {
-    discordCode?: number;
-    status?: number;
-    message?: string;
-    rawBody?: { code?: number; message?: string };
-  };
-  if (err.discordCode === 10062 || err.rawBody?.code === 10062) {
-    return true;
-  }
-  if (err.status === 404 && /Unknown interaction/i.test(err.message ?? "")) {
-    return true;
-  }
-  if (/Unknown interaction/i.test(err.rawBody?.message ?? "")) {
-    return true;
-  }
-  return false;
-}
-
-export function hasRenderableReplyPayload(payload: ReplyPayload): boolean {
-  if (resolveSendableOutboundReplyParts(payload).hasContent) {
-    return true;
-  }
-  const discordData = payload.channelData?.discord as
-    | { components?: TopLevelComponents[] }
-    | undefined;
-  if (Array.isArray(discordData?.components) && discordData.components.length > 0) {
-    return true;
-  }
-  return false;
-}
-
-export async function safeDiscordInteractionCall<T>(
-  label: string,
-  fn: () => Promise<T>,
-): Promise<T | null> {
-  try {
-    return await fn();
-  } catch (error) {
-    if (isDiscordUnknownInteraction(error)) {
-      logVerbose(`discord: ${label} skipped (interaction expired)`);
-      return null;
-    }
-    throw error;
-  }
-}
-
-export async function deliverDiscordInteractionReply(params: {
-  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
-  payload: ReplyPayload;
-  mediaLocalRoots?: readonly string[];
-  textLimit: number;
-  maxLinesPerMessage?: number;
-  preferFollowUp: boolean;
-  responseEphemeral?: boolean;
-  chunkMode: "length" | "newline";
-}) {
-  const { interaction, payload, textLimit, maxLinesPerMessage, preferFollowUp, chunkMode } = params;
-  const reply = resolveSendableOutboundReplyParts(payload);
-  const discordData = payload.channelData?.discord as
-    | { components?: TopLevelComponents[] }
-    | undefined;
-  let firstMessageComponents =
-    Array.isArray(discordData?.components) && discordData.components.length > 0
-      ? discordData.components
-      : undefined;
-
-  let hasReplied = false;
-  const sendMessage = async (
-    content: string,
-    files?: { name: string; data: Buffer }[],
-    components?: TopLevelComponents[],
-  ) => {
-    const contentPayload = content ? { content } : {};
-    const payload =
-      files && files.length > 0
-        ? {
-            ...contentPayload,
-            ...(components ? { components } : {}),
-            ...(params.responseEphemeral !== undefined
-              ? { ephemeral: params.responseEphemeral }
-              : {}),
-            files: files.map((file) => {
-              if (file.data instanceof Blob) {
-                return { name: file.name, data: file.data };
-              }
-              const arrayBuffer = Uint8Array.from(file.data).buffer;
-              return { name: file.name, data: new Blob([arrayBuffer]) };
-            }),
-          }
-        : {
-            ...contentPayload,
-            ...(components ? { components } : {}),
-            ...(params.responseEphemeral !== undefined
-              ? { ephemeral: params.responseEphemeral }
-              : {}),
-          };
-    await safeDiscordInteractionCall("interaction send", async () => {
-      if (!preferFollowUp && !hasReplied) {
-        await interaction.reply(payload);
-        hasReplied = true;
-        firstMessageComponents = undefined;
-        return;
-      }
-      await interaction.followUp(payload);
-      hasReplied = true;
-      firstMessageComponents = undefined;
-    });
-  };
-
-  if (reply.hasMedia) {
-    const media = await Promise.all(
-      reply.mediaUrls.map(async (url) => {
-        const loaded = await loadWebMedia(url, {
-          localRoots: params.mediaLocalRoots,
-        });
-        return {
-          name: loaded.fileName ?? "upload",
-          data: loaded.buffer,
-        };
-      }),
-    );
-    const chunks = resolveTextChunksWithFallback(
-      reply.text,
-      chunkDiscordTextWithMode(reply.text, {
-        maxChars: textLimit,
-        maxLines: maxLinesPerMessage,
-        chunkMode,
-      }),
-    );
-    const caption = chunks[0] ?? "";
-    await sendMessage(caption, media, firstMessageComponents);
-    for (const chunk of chunks.slice(1)) {
-      if (!chunk.trim()) {
-        continue;
-      }
-      await sendMessage(chunk);
-    }
-    return;
-  }
-
-  if (!reply.hasText && !firstMessageComponents) {
-    return;
-  }
-  let chunks =
-    reply.text || firstMessageComponents
-      ? resolveTextChunksWithFallback(
-          reply.text,
-          chunkDiscordTextWithMode(reply.text, {
-            maxChars: textLimit,
-            maxLines: maxLinesPerMessage,
-            chunkMode,
-          }),
-        )
-      : [];
-  if (chunks.length === 0 && firstMessageComponents) {
-    chunks = [""];
-  }
-  for (const chunk of chunks) {
-    if (!chunk.trim() && !firstMessageComponents) {
-      continue;
-    }
-    await sendMessage(chunk, undefined, firstMessageComponents);
-  }
-}

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

@@ -1,91 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
-import type { ResolvedAgentRoute } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import {
-  resolveDiscordBoundConversationRoute,
-  resolveDiscordEffectiveRoute,
-} from "./route-resolution.js";
-import type { ThreadBindingRecord } from "./thread-bindings.js";
-
-type ResolvedConfiguredBindingRoute = ReturnType<
-  typeof conversationRuntime.resolveConfiguredBindingRoute
->;
-type ConfiguredBindingResolution = NonNullable<
-  NonNullable<ResolvedConfiguredBindingRoute>["bindingResolution"]
->;
-
-type DiscordNativeInteractionRouteState = {
-  route: ResolvedAgentRoute;
-  effectiveRoute: ResolvedAgentRoute;
-  boundSessionKey?: string;
-  configuredRoute: ResolvedConfiguredBindingRoute | null;
-  configuredBinding: ConfiguredBindingResolution | null;
-  bindingReadiness: Awaited<
-    ReturnType<typeof conversationRuntime.ensureConfiguredBindingRouteReady>
-  > | null;
-};
-
-export async function resolveDiscordNativeInteractionRouteState(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  guildId?: string;
-  memberRoleIds?: string[];
-  isDirectMessage: boolean;
-  isGroupDm: boolean;
-  directUserId?: string;
-  conversationId: string;
-  parentConversationId?: string;
-  threadBinding?: ThreadBindingRecord;
-  enforceConfiguredBindingReadiness?: boolean;
-}): Promise<DiscordNativeInteractionRouteState> {
-  const route = resolveDiscordBoundConversationRoute({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    guildId: params.guildId,
-    memberRoleIds: params.memberRoleIds,
-    isDirectMessage: params.isDirectMessage,
-    isGroupDm: params.isGroupDm,
-    directUserId: params.directUserId,
-    conversationId: params.conversationId,
-    parentConversationId: params.parentConversationId,
-  });
-  const configuredRoute =
-    params.threadBinding == null
-      ? conversationRuntime.resolveConfiguredBindingRoute({
-          cfg: params.cfg,
-          route,
-          conversation: {
-            channel: "discord",
-            accountId: params.accountId,
-            conversationId: params.conversationId,
-            parentConversationId: params.parentConversationId,
-          },
-        })
-      : null;
-  const configuredBinding = configuredRoute?.bindingResolution ?? null;
-  const configuredBoundSessionKey = normalizeOptionalString(configuredRoute?.boundSessionKey);
-  const boundSessionKey =
-    normalizeOptionalString(params.threadBinding?.targetSessionKey) ?? configuredBoundSessionKey;
-  const effectiveRoute = resolveDiscordEffectiveRoute({
-    route,
-    boundSessionKey,
-    configuredRoute,
-    matchedBy: configuredBinding ? "binding.channel" : undefined,
-  });
-  const bindingReadiness =
-    params.enforceConfiguredBindingReadiness && configuredBinding
-      ? await conversationRuntime.ensureConfiguredBindingRouteReady({
-          cfg: params.cfg,
-          bindingResolution: configuredBinding,
-        })
-      : null;
-  return {
-    route,
-    effectiveRoute,
-    boundSessionKey,
-    configuredRoute,
-    configuredBinding,
-    bindingReadiness,
-  };
-}