@gakr-gakr/discord 0.1.0

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

@@ -0,0 +1,357 @@
+import { resolveDefaultModelForAgent } from "autobot/plugin-sdk/agent-runtime";
+import {
+  resolveStoredModelOverride,
+  serializeCommandArgs,
+  type ChatCommandDefinition,
+  type CommandArgs,
+} from "autobot/plugin-sdk/command-auth-native";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { ResolvedAgentRoute } from "autobot/plugin-sdk/routing";
+import { loadSessionStore, resolveStorePath } from "autobot/plugin-sdk/session-store-runtime";
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+} from "autobot/plugin-sdk/string-coerce-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}`;
+}
+
+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: AutoBotConfig;
+  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: AutoBotConfig;
+  accountId: string;
+  threadBindings: ThreadBindingManager;
+}) {
+  const resolved = await resolveDiscordModelPickerRouteState(params);
+  return resolved.effectiveRoute;
+}
+
+export async function resolveDiscordNativeChoiceContext(params: {
+  interaction: DiscordNativeChoiceInteraction;
+  cfg: AutoBotConfig;
+  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: AutoBotConfig;
+  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: AutoBotConfig;
+  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 {}
+
+  return "auto";
+}
+
+export async function replyWithDiscordModelPickerProviders(params: {
+  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
+  cfg: AutoBotConfig;
+  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 currentProvider = splitDiscordModelRef(currentModel ?? "")?.provider;
+  const initialProvider =
+    currentProvider && data.byProvider.has(currentProvider)
+      ? currentProvider
+      : (data.providers[0] ?? data.resolvedDefault.provider);
+
+  const rendered = renderDiscordModelPickerModelsView({
+    command: params.command,
+    userId: params.userId,
+    data,
+    provider: initialProvider,
+    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.ts

@@ -0,0 +1,185 @@
+import type { ReplyPayload } from "autobot/plugin-sdk/reply-dispatch-runtime";
+import {
+  resolveSendableOutboundReplyParts,
+  resolveTextChunksWithFallback,
+} from "autobot/plugin-sdk/reply-payload";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { loadWebMedia } from "autobot/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

@@ -0,0 +1,91 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import * as conversationRuntime from "autobot/plugin-sdk/conversation-binding-runtime";
+import type { ResolvedAgentRoute } from "autobot/plugin-sdk/routing";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-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: AutoBotConfig;
+  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,
+  };
+}

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

@@ -0,0 +1,76 @@
+import { resolveDirectStatusReplyForSession } from "autobot/plugin-sdk/command-status-runtime";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveChunkMode, resolveTextChunkLimit } from "autobot/plugin-sdk/reply-chunking";
+import type { ResolvedAgentRoute } from "autobot/plugin-sdk/routing";
+import { resolveDiscordMaxLinesPerMessage } from "../accounts.js";
+import type {
+  ButtonInteraction,
+  CommandInteraction,
+  StringSelectMenuInteraction,
+} from "../internal/discord.js";
+import type { DispatchDiscordCommandInteractionResult } from "./native-command-dispatch.js";
+import {
+  deliverDiscordInteractionReply,
+  hasRenderableReplyPayload,
+} from "./native-command-reply.js";
+import type { DiscordConfig } from "./native-command.types.js";
+
+type ResolveDirectStatusReplyForSession = typeof resolveDirectStatusReplyForSession;
+
+export async function maybeDeliverDiscordDirectStatus(params: {
+  commandName: string;
+  suppressReplies?: boolean;
+  resolveDirectStatusReplyForSession: ResolveDirectStatusReplyForSession;
+  cfg: AutoBotConfig;
+  discordConfig: DiscordConfig;
+  accountId: string;
+  sessionKey: string;
+  commandTargetSessionKey?: string | null;
+  channel: "discord";
+  senderId: string;
+  senderIsOwner: boolean;
+  isAuthorizedSender: boolean;
+  isGroup: boolean;
+  defaultGroupActivation: () => "always" | "mention";
+  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
+  mediaLocalRoots: readonly string[];
+  preferFollowUp: boolean;
+  responseEphemeral?: boolean;
+  effectiveRoute: ResolvedAgentRoute;
+  respond: (content: string, options?: { ephemeral?: boolean }) => Promise<void>;
+}): Promise<DispatchDiscordCommandInteractionResult | null> {
+  if (params.suppressReplies || params.commandName !== "status") {
+    return null;
+  }
+  const statusReply = await params.resolveDirectStatusReplyForSession({
+    cfg: params.cfg,
+    sessionKey: params.commandTargetSessionKey?.trim() || params.sessionKey,
+    channel: params.channel,
+    senderId: params.senderId,
+    senderIsOwner: params.senderIsOwner,
+    isAuthorizedSender: params.isAuthorizedSender,
+    isGroup: params.isGroup,
+    defaultGroupActivation: params.defaultGroupActivation,
+  });
+  if (statusReply && hasRenderableReplyPayload(statusReply)) {
+    await deliverDiscordInteractionReply({
+      interaction: params.interaction,
+      payload: statusReply,
+      mediaLocalRoots: params.mediaLocalRoots,
+      textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, {
+        fallbackLimit: 2000,
+      }),
+      maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
+        cfg: params.cfg,
+        discordConfig: params.discordConfig,
+        accountId: params.accountId,
+      }),
+      preferFollowUp: params.preferFollowUp,
+      responseEphemeral: params.responseEphemeral,
+      chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId),
+    });
+    return { accepted: true, effectiveRoute: params.effectiveRoute };
+  }
+  await params.respond("Status unavailable.");
+  return { accepted: true, effectiveRoute: params.effectiveRoute };
+}