openclawdreams 1.3.3 → 1.3.4

package/dist/openclaw/src/discord/monitor/native-command.js

@@ -0,0 +1,1412 @@
+import { Button, ChannelType, Command, Container, Row, StringSelectMenu, TextDisplay, } from "@buape/carbon";
+import { ApplicationCommandOptionType, ButtonStyle } from "discord-api-types/v10";
+import { ensureConfiguredAcpRouteReady, resolveConfiguredAcpRoute, } from "../../acp/persistent-bindings.route.js";
+import { resolveHumanDelayConfig } from "../../agents/identity.js";
+import { resolveChunkMode, resolveTextChunkLimit } from "../../auto-reply/chunk.js";
+import { buildCommandTextFromArgs, findCommandByNativeName, listChatCommands, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs, } from "../../auto-reply/commands-registry.js";
+import { finalizeInboundContext } from "../../auto-reply/reply/inbound-context.js";
+import { resolveStoredModelOverride } from "../../auto-reply/reply/model-selection.js";
+import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
+import { resolveCommandAuthorizedFromAuthorizers } from "../../channels/command-gating.js";
+import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
+import { isDangerousNameMatchingEnabled } from "../../config/dangerous-name-matching.js";
+import { resolveOpenProviderRuntimeGroupPolicy } from "../../config/runtime-group-policy.js";
+import { loadSessionStore, resolveStorePath } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { createSubsystemLogger } from "../../logging/subsystem.js";
+import { getAgentScopedMediaLocalRoots } from "../../media/local-roots.js";
+import { buildPairingReply } from "../../pairing/pairing-messages.js";
+import { executePluginCommand, matchPluginCommand } from "../../plugins/commands.js";
+import { resolveAgentRoute } from "../../routing/resolve-route.js";
+import { resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
+import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
+import { chunkItems } from "../../utils/chunk-items.js";
+import { withTimeout } from "../../utils/with-timeout.js";
+import { loadWebMedia } from "../../web/media.js";
+import { chunkDiscordTextWithMode } from "../chunk.js";
+import { isDiscordGroupAllowedByPolicy, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordMemberAccessState, resolveDiscordOwnerAccess, resolveDiscordOwnerAllowFrom, } from "./allow-list.js";
+import { resolveDiscordDmCommandAccess } from "./dm-command-auth.js";
+import { handleDiscordDmCommandDecision } from "./dm-command-decision.js";
+import { resolveDiscordChannelInfo } from "./message-utils.js";
+import { readDiscordModelPickerRecentModels, recordDiscordModelPickerRecentModel, } from "./model-picker-preferences.js";
+import { DISCORD_MODEL_PICKER_CUSTOM_ID_KEY, loadDiscordModelPickerData, parseDiscordModelPickerData, renderDiscordModelPickerModelsView, renderDiscordModelPickerProvidersView, renderDiscordModelPickerRecentsView, toDiscordModelPickerMessagePayload, } from "./model-picker.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
+import { resolveDiscordThreadParentInfo } from "./threading.js";
+const log = createSubsystemLogger("discord/native-command");
+function buildDiscordCommandOptions(params) {
+    const { command, cfg } = params;
+    const args = command.args;
+    if (!args || args.length === 0) {
+        return undefined;
+    }
+    return args.map((arg) => {
+        const required = arg.required ?? false;
+        if (arg.type === "number") {
+            return {
+                name: arg.name,
+                description: arg.description,
+                type: ApplicationCommandOptionType.Number,
+                required,
+            };
+        }
+        if (arg.type === "boolean") {
+            return {
+                name: arg.name,
+                description: arg.description,
+                type: ApplicationCommandOptionType.Boolean,
+                required,
+            };
+        }
+        const resolvedChoices = resolveCommandArgChoices({ command, arg, cfg });
+        const shouldAutocomplete = arg.preferAutocomplete === true ||
+            (resolvedChoices.length > 0 &&
+                (typeof arg.choices === "function" || resolvedChoices.length > 25));
+        const autocomplete = shouldAutocomplete
+            ? async (interaction) => {
+                const focused = interaction.options.getFocused();
+                const focusValue = typeof focused?.value === "string" ? focused.value.trim().toLowerCase() : "";
+                const choices = resolveCommandArgChoices({ command, arg, cfg });
+                const filtered = focusValue
+                    ? choices.filter((choice) => choice.label.toLowerCase().includes(focusValue))
+                    : choices;
+                await interaction.respond(filtered.slice(0, 25).map((choice) => ({ name: choice.label, value: choice.value })));
+            }
+            : undefined;
+        const choices = resolvedChoices.length > 0 && !autocomplete
+            ? resolvedChoices
+                .slice(0, 25)
+                .map((choice) => ({ name: choice.label, value: choice.value }))
+            : undefined;
+        return {
+            name: arg.name,
+            description: arg.description,
+            type: ApplicationCommandOptionType.String,
+            required,
+            choices,
+            autocomplete,
+        };
+    });
+}
+function readDiscordCommandArgs(interaction, definitions) {
+    if (!definitions || definitions.length === 0) {
+        return undefined;
+    }
+    const values = {};
+    for (const definition of definitions) {
+        let value;
+        if (definition.type === "number") {
+            value = interaction.options.getNumber(definition.name) ?? null;
+        }
+        else if (definition.type === "boolean") {
+            value = interaction.options.getBoolean(definition.name) ?? null;
+        }
+        else {
+            value = interaction.options.getString(definition.name) ?? null;
+        }
+        if (value != null) {
+            values[definition.name] = value;
+        }
+    }
+    return Object.keys(values).length > 0 ? { values } : undefined;
+}
+const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
+function createCommandArgsWithValue(params) {
+    const values = { [params.argName]: params.value };
+    return { values };
+}
+function encodeDiscordCommandArgValue(value) {
+    return encodeURIComponent(value);
+}
+function decodeDiscordCommandArgValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function isDiscordUnknownInteraction(error) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const err = error;
+    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;
+}
+function hasRenderableReplyPayload(payload) {
+    if ((payload.text ?? "").trim()) {
+        return true;
+    }
+    if ((payload.mediaUrl ?? "").trim()) {
+        return true;
+    }
+    if (payload.mediaUrls?.some((entry) => entry.trim())) {
+        return true;
+    }
+    return false;
+}
+async function safeDiscordInteractionCall(label, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (isDiscordUnknownInteraction(error)) {
+            logVerbose(`discord: ${label} skipped (interaction expired)`);
+            return null;
+        }
+        throw error;
+    }
+}
+function buildDiscordCommandArgCustomId(params) {
+    return [
+        `${DISCORD_COMMAND_ARG_CUSTOM_ID_KEY}:command=${encodeDiscordCommandArgValue(params.command)}`,
+        `arg=${encodeDiscordCommandArgValue(params.arg)}`,
+        `value=${encodeDiscordCommandArgValue(params.value)}`,
+        `user=${encodeDiscordCommandArgValue(params.userId)}`,
+    ].join(";");
+}
+function parseDiscordCommandArgData(data) {
+    if (!data || typeof data !== "object") {
+        return null;
+    }
+    const coerce = (value) => typeof value === "string" || typeof value === "number" ? String(value) : "";
+    const rawCommand = coerce(data.command);
+    const rawArg = coerce(data.arg);
+    const rawValue = coerce(data.value);
+    const rawUser = coerce(data.user);
+    if (!rawCommand || !rawArg || !rawValue || !rawUser) {
+        return null;
+    }
+    return {
+        command: decodeDiscordCommandArgValue(rawCommand),
+        arg: decodeDiscordCommandArgValue(rawArg),
+        value: decodeDiscordCommandArgValue(rawValue),
+        userId: decodeDiscordCommandArgValue(rawUser),
+    };
+}
+function resolveDiscordModelPickerCommandContext(command) {
+    const normalized = (command.nativeName ?? command.key).trim().toLowerCase();
+    if (normalized === "model" || normalized === "models") {
+        return normalized;
+    }
+    return null;
+}
+function resolveCommandArgStringValue(args, key) {
+    const value = args?.values?.[key];
+    if (typeof value !== "string") {
+        return "";
+    }
+    return value.trim();
+}
+function shouldOpenDiscordModelPickerFromCommand(params) {
+    const context = resolveDiscordModelPickerCommandContext(params.command);
+    if (!context) {
+        return null;
+    }
+    const serializedArgs = serializeCommandArgs(params.command, params.commandArgs)?.trim() ?? "";
+    if (context === "model") {
+        const modelValue = resolveCommandArgStringValue(params.commandArgs, "model");
+        return !modelValue && !serializedArgs ? context : null;
+    }
+    return serializedArgs ? null : context;
+}
+function buildDiscordModelPickerCurrentModel(defaultProvider, defaultModel) {
+    return `${defaultProvider}/${defaultModel}`;
+}
+function buildDiscordModelPickerAllowedModelRefs(data) {
+    const out = new Set();
+    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;
+}
+function resolveDiscordModelPickerPreferenceScope(params) {
+    return {
+        accountId: params.accountId,
+        guildId: params.interaction.guild?.id ?? undefined,
+        userId: params.userId,
+    };
+}
+function buildDiscordModelPickerNoticePayload(message) {
+    return {
+        components: [new Container([new TextDisplay(message)])],
+    };
+}
+async function resolveDiscordModelPickerRoute(params) {
+    const { interaction, cfg, accountId } = params;
+    const channel = interaction.channel;
+    const channelType = channel?.type;
+    const isDirectMessage = channelType === ChannelType.DM;
+    const isGroupDm = channelType === ChannelType.GroupDM;
+    const isThreadChannel = channelType === ChannelType.PublicThread ||
+        channelType === ChannelType.PrivateThread ||
+        channelType === ChannelType.AnnouncementThread;
+    const rawChannelId = channel?.id ?? "unknown";
+    const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
+        ? interaction.rawData.member.roles.map((roleId) => String(roleId))
+        : [];
+    let threadParentId;
+    if (interaction.guild && channel && isThreadChannel && rawChannelId) {
+        const channelInfo = await resolveDiscordChannelInfo(interaction.client, rawChannelId);
+        const parentInfo = await resolveDiscordThreadParentInfo({
+            client: interaction.client,
+            threadChannel: {
+                id: rawChannelId,
+                name: "name" in channel ? channel.name : undefined,
+                parentId: "parentId" in channel ? (channel.parentId ?? undefined) : undefined,
+                parent: undefined,
+            },
+            channelInfo,
+        });
+        threadParentId = parentInfo.id;
+    }
+    const route = resolveAgentRoute({
+        cfg,
+        channel: "discord",
+        accountId,
+        guildId: interaction.guild?.id ?? undefined,
+        memberRoleIds,
+        peer: {
+            kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+            id: isDirectMessage ? (interaction.user?.id ?? rawChannelId) : rawChannelId,
+        },
+        parentPeer: threadParentId ? { kind: "channel", id: threadParentId } : undefined,
+    });
+    const threadBinding = isThreadChannel
+        ? params.threadBindings.getByThreadId(rawChannelId)
+        : undefined;
+    const boundSessionKey = threadBinding?.targetSessionKey?.trim();
+    const boundAgentId = boundSessionKey ? resolveAgentIdFromSessionKey(boundSessionKey) : undefined;
+    return boundSessionKey
+        ? {
+            ...route,
+            sessionKey: boundSessionKey,
+            agentId: boundAgentId ?? route.agentId,
+        }
+        : route;
+}
+function resolveDiscordModelPickerCurrentModel(params) {
+    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,
+        });
+        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;
+    }
+}
+async function replyWithDiscordModelPickerProviders(params) {
+    const data = await loadDiscordModelPickerData(params.cfg);
+    const route = await resolveDiscordModelPickerRoute({
+        interaction: params.interaction,
+        cfg: params.cfg,
+        accountId: params.accountId,
+        threadBindings: params.threadBindings,
+    });
+    const currentModel = resolveDiscordModelPickerCurrentModel({
+        cfg: params.cfg,
+        route,
+        data,
+    });
+    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,
+        quickModels,
+    });
+    const payload = {
+        ...toDiscordModelPickerMessagePayload(rendered),
+        ephemeral: true,
+    };
+    await safeDiscordInteractionCall("model picker reply", async () => {
+        if (params.preferFollowUp) {
+            await params.interaction.followUp(payload);
+            return;
+        }
+        await params.interaction.reply(payload);
+    });
+}
+function resolveModelPickerSelectionValue(interaction) {
+    const rawValues = interaction.values;
+    if (!Array.isArray(rawValues) || rawValues.length === 0) {
+        return null;
+    }
+    const first = rawValues[0];
+    if (typeof first !== "string") {
+        return null;
+    }
+    const trimmed = first.trim();
+    return trimmed || null;
+}
+function buildDiscordModelPickerSelectionCommand(params) {
+    const commandDefinition = findCommandByNativeName("model", "discord") ??
+        listChatCommands().find((entry) => entry.key === "model");
+    if (!commandDefinition) {
+        return null;
+    }
+    const commandArgs = {
+        values: {
+            model: params.modelRef,
+        },
+        raw: params.modelRef,
+    };
+    return {
+        command: commandDefinition,
+        args: commandArgs,
+        prompt: buildCommandTextFromArgs(commandDefinition, commandArgs),
+    };
+}
+function listDiscordModelPickerProviderModels(data, provider) {
+    const modelSet = data.byProvider.get(provider);
+    if (!modelSet) {
+        return [];
+    }
+    return [...modelSet].toSorted();
+}
+function resolveDiscordModelPickerModelIndex(params) {
+    const models = listDiscordModelPickerProviderModels(params.data, params.provider);
+    if (!models.length) {
+        return null;
+    }
+    const index = models.indexOf(params.model);
+    if (index < 0) {
+        return null;
+    }
+    return index + 1;
+}
+function resolveDiscordModelPickerModelByIndex(params) {
+    if (!params.modelIndex || params.modelIndex < 1) {
+        return null;
+    }
+    const models = listDiscordModelPickerProviderModels(params.data, params.provider);
+    if (!models.length) {
+        return null;
+    }
+    return models[params.modelIndex - 1] ?? null;
+}
+function splitDiscordModelRef(modelRef) {
+    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 };
+}
+async function handleDiscordModelPickerInteraction(interaction, data, ctx) {
+    const parsed = parseDiscordModelPickerData(data);
+    if (!parsed) {
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload("Sorry, that model picker interaction is no longer available.")));
+        return;
+    }
+    if (interaction.user?.id && interaction.user.id !== parsed.userId) {
+        await safeDiscordInteractionCall("model picker ack", () => interaction.acknowledge());
+        return;
+    }
+    const pickerData = await loadDiscordModelPickerData(ctx.cfg);
+    const route = await resolveDiscordModelPickerRoute({
+        interaction,
+        cfg: ctx.cfg,
+        accountId: ctx.accountId,
+        threadBindings: ctx.threadBindings,
+    });
+    const currentModelRef = resolveDiscordModelPickerCurrentModel({
+        cfg: ctx.cfg,
+        route,
+        data: pickerData,
+    });
+    const allowedModelRefs = buildDiscordModelPickerAllowedModelRefs(pickerData);
+    const preferenceScope = resolveDiscordModelPickerPreferenceScope({
+        interaction,
+        accountId: ctx.accountId,
+        userId: parsed.userId,
+    });
+    const quickModels = await readDiscordModelPickerRecentModels({
+        scope: preferenceScope,
+        allowedModelRefs,
+        limit: 5,
+    });
+    if (parsed.action === "recents") {
+        const rendered = renderDiscordModelPickerRecentsView({
+            command: parsed.command,
+            userId: parsed.userId,
+            data: pickerData,
+            quickModels,
+            currentModel: currentModelRef,
+            provider: parsed.provider,
+            page: parsed.page,
+            providerPage: parsed.providerPage,
+        });
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(toDiscordModelPickerMessagePayload(rendered)));
+        return;
+    }
+    if (parsed.action === "back" && parsed.view === "providers") {
+        const rendered = renderDiscordModelPickerProvidersView({
+            command: parsed.command,
+            userId: parsed.userId,
+            data: pickerData,
+            page: parsed.page,
+            currentModel: currentModelRef,
+        });
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(toDiscordModelPickerMessagePayload(rendered)));
+        return;
+    }
+    if (parsed.action === "back" && parsed.view === "models") {
+        const provider = parsed.provider ??
+            splitDiscordModelRef(currentModelRef ?? "")?.provider ??
+            pickerData.resolvedDefault.provider;
+        const rendered = renderDiscordModelPickerModelsView({
+            command: parsed.command,
+            userId: parsed.userId,
+            data: pickerData,
+            provider,
+            page: parsed.page ?? 1,
+            providerPage: parsed.providerPage ?? 1,
+            currentModel: currentModelRef,
+            quickModels,
+        });
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(toDiscordModelPickerMessagePayload(rendered)));
+        return;
+    }
+    if (parsed.action === "provider") {
+        const selectedProvider = resolveModelPickerSelectionValue(interaction) ?? parsed.provider;
+        if (!selectedProvider || !pickerData.byProvider.has(selectedProvider)) {
+            await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload("Sorry, that provider isn't available anymore.")));
+            return;
+        }
+        const rendered = renderDiscordModelPickerModelsView({
+            command: parsed.command,
+            userId: parsed.userId,
+            data: pickerData,
+            provider: selectedProvider,
+            page: 1,
+            providerPage: parsed.providerPage ?? parsed.page,
+            currentModel: currentModelRef,
+            quickModels,
+        });
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(toDiscordModelPickerMessagePayload(rendered)));
+        return;
+    }
+    if (parsed.action === "model") {
+        const selectedModel = resolveModelPickerSelectionValue(interaction);
+        const provider = parsed.provider;
+        if (!provider || !selectedModel) {
+            await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload("Sorry, I couldn't read that model selection.")));
+            return;
+        }
+        const modelIndex = resolveDiscordModelPickerModelIndex({
+            data: pickerData,
+            provider,
+            model: selectedModel,
+        });
+        if (!modelIndex) {
+            await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload("Sorry, that model isn't available anymore.")));
+            return;
+        }
+        const modelRef = `${provider}/${selectedModel}`;
+        const rendered = renderDiscordModelPickerModelsView({
+            command: parsed.command,
+            userId: parsed.userId,
+            data: pickerData,
+            provider,
+            page: parsed.page,
+            providerPage: parsed.providerPage ?? 1,
+            currentModel: currentModelRef,
+            pendingModel: modelRef,
+            pendingModelIndex: modelIndex,
+            quickModels,
+        });
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(toDiscordModelPickerMessagePayload(rendered)));
+        return;
+    }
+    if (parsed.action === "submit" || parsed.action === "reset" || parsed.action === "quick") {
+        let modelRef = null;
+        if (parsed.action === "reset") {
+            modelRef = `${pickerData.resolvedDefault.provider}/${pickerData.resolvedDefault.model}`;
+        }
+        else if (parsed.action === "quick") {
+            const slot = parsed.recentSlot ?? 0;
+            modelRef = slot >= 1 ? (quickModels[slot - 1] ?? null) : null;
+        }
+        else if (parsed.view === "recents") {
+            const defaultModelRef = `${pickerData.resolvedDefault.provider}/${pickerData.resolvedDefault.model}`;
+            const dedupedRecents = quickModels.filter((ref) => ref !== defaultModelRef);
+            const slot = parsed.recentSlot ?? 0;
+            if (slot === 1) {
+                modelRef = defaultModelRef;
+            }
+            else if (slot >= 2) {
+                modelRef = dedupedRecents[slot - 2] ?? null;
+            }
+        }
+        else {
+            const provider = parsed.provider;
+            const selectedModel = resolveDiscordModelPickerModelByIndex({
+                data: pickerData,
+                provider: provider ?? "",
+                modelIndex: parsed.modelIndex,
+            });
+            modelRef = provider && selectedModel ? `${provider}/${selectedModel}` : null;
+        }
+        const parsedModelRef = modelRef ? splitDiscordModelRef(modelRef) : null;
+        if (!parsedModelRef ||
+            !pickerData.byProvider.get(parsedModelRef.provider)?.has(parsedModelRef.model)) {
+            await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload("That selection expired. Please choose a model again.")));
+            return;
+        }
+        const resolvedModelRef = `${parsedModelRef.provider}/${parsedModelRef.model}`;
+        const selectionCommand = buildDiscordModelPickerSelectionCommand({
+            modelRef: resolvedModelRef,
+        });
+        if (!selectionCommand) {
+            await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload("Sorry, /model is unavailable right now.")));
+            return;
+        }
+        const updateResult = await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload(`Applying model change to ${resolvedModelRef}...`)));
+        if (updateResult === null) {
+            return;
+        }
+        try {
+            await withTimeout(dispatchDiscordCommandInteraction({
+                interaction,
+                prompt: selectionCommand.prompt,
+                command: selectionCommand.command,
+                commandArgs: selectionCommand.args,
+                cfg: ctx.cfg,
+                discordConfig: ctx.discordConfig,
+                accountId: ctx.accountId,
+                sessionPrefix: ctx.sessionPrefix,
+                preferFollowUp: true,
+                threadBindings: ctx.threadBindings,
+                suppressReplies: true,
+            }), 12000);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "timeout") {
+                await safeDiscordInteractionCall("model picker follow-up", () => interaction.followUp({
+                    ...buildDiscordModelPickerNoticePayload(`⏳ Model change to ${resolvedModelRef} is still processing. Check /status in a few seconds.`),
+                    ephemeral: true,
+                }));
+                return;
+            }
+            await safeDiscordInteractionCall("model picker follow-up", () => interaction.followUp({
+                ...buildDiscordModelPickerNoticePayload(`❌ Failed to apply ${resolvedModelRef}. Try /model ${resolvedModelRef} directly.`),
+                ephemeral: true,
+            }));
+            return;
+        }
+        const effectiveModelRef = resolveDiscordModelPickerCurrentModel({
+            cfg: ctx.cfg,
+            route,
+            data: pickerData,
+        });
+        const persisted = effectiveModelRef === resolvedModelRef;
+        if (!persisted) {
+            logVerbose(`discord: model picker override mismatch — expected ${resolvedModelRef} but read ${effectiveModelRef} from session key ${route.sessionKey}`);
+        }
+        if (persisted) {
+            await recordDiscordModelPickerRecentModel({
+                scope: preferenceScope,
+                modelRef: resolvedModelRef,
+                limit: 5,
+            }).catch(() => undefined);
+        }
+        await safeDiscordInteractionCall("model picker follow-up", () => interaction.followUp({
+            ...buildDiscordModelPickerNoticePayload(persisted
+                ? `✅ Model set to ${resolvedModelRef}.`
+                : `⚠️ Tried to set ${resolvedModelRef}, but current model is ${effectiveModelRef}.`),
+            ephemeral: true,
+        }));
+        return;
+    }
+    if (parsed.action === "cancel") {
+        const displayModel = currentModelRef ?? "default";
+        await safeDiscordInteractionCall("model picker update", () => interaction.update(buildDiscordModelPickerNoticePayload(`ℹ️ Model kept as ${displayModel}.`)));
+        return;
+    }
+}
+async function handleDiscordCommandArgInteraction(interaction, data, ctx) {
+    const parsed = parseDiscordCommandArgData(data);
+    if (!parsed) {
+        await safeDiscordInteractionCall("command arg update", () => interaction.update({
+            content: "Sorry, that selection is no longer available.",
+            components: [],
+        }));
+        return;
+    }
+    if (interaction.user?.id && interaction.user.id !== parsed.userId) {
+        await safeDiscordInteractionCall("command arg ack", () => interaction.acknowledge());
+        return;
+    }
+    const commandDefinition = findCommandByNativeName(parsed.command, "discord") ??
+        listChatCommands().find((entry) => entry.key === parsed.command);
+    if (!commandDefinition) {
+        await safeDiscordInteractionCall("command arg update", () => interaction.update({
+            content: "Sorry, that command is no longer available.",
+            components: [],
+        }));
+        return;
+    }
+    const argUpdateResult = await safeDiscordInteractionCall("command arg update", () => interaction.update({
+        content: `✅ Selected ${parsed.value}.`,
+        components: [],
+    }));
+    if (argUpdateResult === null) {
+        return;
+    }
+    const commandArgs = createCommandArgsWithValue({
+        argName: parsed.arg,
+        value: parsed.value,
+    });
+    const commandArgsWithRaw = {
+        ...commandArgs,
+        raw: serializeCommandArgs(commandDefinition, commandArgs),
+    };
+    const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
+    await dispatchDiscordCommandInteraction({
+        interaction,
+        prompt,
+        command: commandDefinition,
+        commandArgs: commandArgsWithRaw,
+        cfg: ctx.cfg,
+        discordConfig: ctx.discordConfig,
+        accountId: ctx.accountId,
+        sessionPrefix: ctx.sessionPrefix,
+        preferFollowUp: true,
+        threadBindings: ctx.threadBindings,
+    });
+}
+class DiscordCommandArgButton extends Button {
+    label;
+    customId;
+    style = ButtonStyle.Secondary;
+    cfg;
+    discordConfig;
+    accountId;
+    sessionPrefix;
+    threadBindings;
+    constructor(params) {
+        super();
+        this.label = params.label;
+        this.customId = params.customId;
+        this.cfg = params.cfg;
+        this.discordConfig = params.discordConfig;
+        this.accountId = params.accountId;
+        this.sessionPrefix = params.sessionPrefix;
+        this.threadBindings = params.threadBindings;
+    }
+    async run(interaction, data) {
+        await handleDiscordCommandArgInteraction(interaction, data, {
+            cfg: this.cfg,
+            discordConfig: this.discordConfig,
+            accountId: this.accountId,
+            sessionPrefix: this.sessionPrefix,
+            threadBindings: this.threadBindings,
+        });
+    }
+}
+class DiscordCommandArgFallbackButton extends Button {
+    label = "cmdarg";
+    customId = "cmdarg:seed=1";
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordCommandArgInteraction(interaction, data, this.ctx);
+    }
+}
+export function createDiscordCommandArgFallbackButton(params) {
+    return new DiscordCommandArgFallbackButton(params);
+}
+class DiscordModelPickerFallbackButton extends Button {
+    label = DISCORD_MODEL_PICKER_CUSTOM_ID_KEY;
+    customId = `${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:seed=btn`;
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordModelPickerInteraction(interaction, data, this.ctx);
+    }
+}
+class DiscordModelPickerFallbackSelect extends StringSelectMenu {
+    customId = `${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:seed=sel`;
+    options = [];
+    ctx;
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
+    async run(interaction, data) {
+        await handleDiscordModelPickerInteraction(interaction, data, this.ctx);
+    }
+}
+export function createDiscordModelPickerFallbackButton(params) {
+    return new DiscordModelPickerFallbackButton(params);
+}
+export function createDiscordModelPickerFallbackSelect(params) {
+    return new DiscordModelPickerFallbackSelect(params);
+}
+function buildDiscordCommandArgMenu(params) {
+    const { command, menu, interaction } = params;
+    const commandLabel = command.nativeName ?? command.key;
+    const userId = interaction.user?.id ?? "";
+    const rows = chunkItems(menu.choices, 4).map((choices) => {
+        const buttons = choices.map((choice) => new DiscordCommandArgButton({
+            label: choice.label,
+            customId: buildDiscordCommandArgCustomId({
+                command: commandLabel,
+                arg: menu.arg.name,
+                value: choice.value,
+                userId,
+            }),
+            cfg: params.cfg,
+            discordConfig: params.discordConfig,
+            accountId: params.accountId,
+            sessionPrefix: params.sessionPrefix,
+            threadBindings: params.threadBindings,
+        }));
+        return new Row(buttons);
+    });
+    const content = menu.title ?? `Choose ${menu.arg.description || menu.arg.name} for /${commandLabel}.`;
+    return { content, components: rows };
+}
+export function createDiscordNativeCommand(params) {
+    const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings, } = params;
+    const commandDefinition = findCommandByNativeName(command.name, "discord") ??
+        {
+            key: command.name,
+            nativeName: command.name,
+            description: command.description,
+            textAliases: [],
+            acceptsArgs: command.acceptsArgs,
+            args: command.args,
+            argsParsing: "none",
+            scope: "native",
+        };
+    const argDefinitions = commandDefinition.args ?? command.args;
+    const commandOptions = buildDiscordCommandOptions({
+        command: commandDefinition,
+        cfg,
+    });
+    const options = commandOptions
+        ? commandOptions
+        : command.acceptsArgs
+            ? [
+                {
+                    name: "input",
+                    description: "Command input",
+                    type: ApplicationCommandOptionType.String,
+                    required: false,
+                },
+            ]
+            : undefined;
+    return new (class extends Command {
+        name = command.name;
+        description = command.description;
+        defer = true;
+        ephemeral = ephemeralDefault;
+        options = options;
+        async run(interaction) {
+            const commandArgs = argDefinitions?.length
+                ? readDiscordCommandArgs(interaction, argDefinitions)
+                : command.acceptsArgs
+                    ? parseCommandArgs(commandDefinition, interaction.options.getString("input") ?? "")
+                    : undefined;
+            const commandArgsWithRaw = commandArgs
+                ? {
+                    ...commandArgs,
+                    raw: serializeCommandArgs(commandDefinition, commandArgs) ?? commandArgs.raw,
+                }
+                : undefined;
+            const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
+            await dispatchDiscordCommandInteraction({
+                interaction,
+                prompt,
+                command: commandDefinition,
+                commandArgs: commandArgsWithRaw,
+                cfg,
+                discordConfig,
+                accountId,
+                sessionPrefix,
+                preferFollowUp: false,
+                threadBindings,
+            });
+        }
+    })();
+}
+async function dispatchDiscordCommandInteraction(params) {
+    const { interaction, prompt, command, commandArgs, cfg, discordConfig, accountId, sessionPrefix, preferFollowUp, threadBindings, suppressReplies, } = params;
+    const respond = async (content, options) => {
+        const payload = {
+            content,
+            ...(options?.ephemeral !== undefined ? { ephemeral: options.ephemeral } : {}),
+        };
+        await safeDiscordInteractionCall("interaction reply", async () => {
+            if (preferFollowUp) {
+                await interaction.followUp(payload);
+                return;
+            }
+            await interaction.reply(payload);
+        });
+    };
+    const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+    const user = interaction.user;
+    if (!user) {
+        return;
+    }
+    const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
+    const channel = interaction.channel;
+    const channelType = channel?.type;
+    const isDirectMessage = channelType === ChannelType.DM;
+    const isGroupDm = channelType === ChannelType.GroupDM;
+    const isThreadChannel = channelType === ChannelType.PublicThread ||
+        channelType === ChannelType.PrivateThread ||
+        channelType === ChannelType.AnnouncementThread;
+    const channelName = channel && "name" in channel ? channel.name : undefined;
+    const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
+    const rawChannelId = channel?.id ?? "";
+    const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
+        ? interaction.rawData.member.roles.map((roleId) => String(roleId))
+        : [];
+    const allowNameMatching = isDangerousNameMatchingEnabled(discordConfig);
+    const { ownerAllowList, ownerAllowed: ownerOk } = resolveDiscordOwnerAccess({
+        allowFrom: discordConfig?.allowFrom ?? discordConfig?.dm?.allowFrom ?? [],
+        sender: {
+            id: sender.id,
+            name: sender.name,
+            tag: sender.tag,
+        },
+        allowNameMatching,
+    });
+    const guildInfo = resolveDiscordGuildEntry({
+        guild: interaction.guild ?? undefined,
+        guildEntries: discordConfig?.guilds,
+    });
+    let threadParentId;
+    let threadParentName;
+    let threadParentSlug = "";
+    if (interaction.guild && channel && isThreadChannel && rawChannelId) {
+        // Threads inherit parent channel config unless explicitly overridden.
+        const channelInfo = await resolveDiscordChannelInfo(interaction.client, rawChannelId);
+        const parentInfo = await resolveDiscordThreadParentInfo({
+            client: interaction.client,
+            threadChannel: {
+                id: rawChannelId,
+                name: channelName,
+                parentId: "parentId" in channel ? (channel.parentId ?? undefined) : undefined,
+                parent: undefined,
+            },
+            channelInfo,
+        });
+        threadParentId = parentInfo.id;
+        threadParentName = parentInfo.name;
+        threadParentSlug = threadParentName ? normalizeDiscordSlug(threadParentName) : "";
+    }
+    const channelConfig = interaction.guild
+        ? resolveDiscordChannelConfigWithFallback({
+            guildInfo,
+            channelId: rawChannelId,
+            channelName,
+            channelSlug,
+            parentId: threadParentId,
+            parentName: threadParentName,
+            parentSlug: threadParentSlug,
+            scope: isThreadChannel ? "thread" : "channel",
+        })
+        : null;
+    if (channelConfig?.enabled === false) {
+        await respond("This channel is disabled.");
+        return;
+    }
+    if (interaction.guild && channelConfig?.allowed === false) {
+        await respond("This channel is not allowed.");
+        return;
+    }
+    if (useAccessGroups && interaction.guild) {
+        const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
+        const channelAllowed = channelConfig?.allowed !== false;
+        const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
+            providerConfigPresent: cfg.channels?.discord !== undefined,
+            groupPolicy: discordConfig?.groupPolicy,
+            defaultGroupPolicy: cfg.channels?.defaults?.groupPolicy,
+        });
+        const allowByPolicy = isDiscordGroupAllowedByPolicy({
+            groupPolicy,
+            guildAllowlisted: Boolean(guildInfo),
+            channelAllowlistConfigured,
+            channelAllowed,
+        });
+        if (!allowByPolicy) {
+            await respond("This channel is not allowed.");
+            return;
+        }
+    }
+    const dmEnabled = discordConfig?.dm?.enabled ?? true;
+    const dmPolicy = discordConfig?.dmPolicy ?? discordConfig?.dm?.policy ?? "pairing";
+    let commandAuthorized = true;
+    if (isDirectMessage) {
+        if (!dmEnabled || dmPolicy === "disabled") {
+            await respond("Discord DMs are disabled.");
+            return;
+        }
+        const dmAccess = await resolveDiscordDmCommandAccess({
+            accountId,
+            dmPolicy,
+            configuredAllowFrom: discordConfig?.allowFrom ?? discordConfig?.dm?.allowFrom ?? [],
+            sender: {
+                id: sender.id,
+                name: sender.name,
+                tag: sender.tag,
+            },
+            allowNameMatching,
+            useAccessGroups,
+        });
+        commandAuthorized = dmAccess.commandAuthorized;
+        if (dmAccess.decision !== "allow") {
+            await handleDiscordDmCommandDecision({
+                dmAccess,
+                accountId,
+                sender: {
+                    id: user.id,
+                    tag: sender.tag,
+                    name: sender.name,
+                },
+                onPairingCreated: async (code) => {
+                    await respond(buildPairingReply({
+                        channel: "discord",
+                        idLine: `Your Discord user id: ${user.id}`,
+                        code,
+                    }), { ephemeral: true });
+                },
+                onUnauthorized: async () => {
+                    await respond("You are not authorized to use this command.", { ephemeral: true });
+                },
+            });
+            return;
+        }
+    }
+    if (!isDirectMessage) {
+        const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+            channelConfig,
+            guildInfo,
+            memberRoleIds,
+            sender,
+            allowNameMatching,
+        });
+        const authorizers = useAccessGroups
+            ? [
+                { configured: ownerAllowList != null, allowed: ownerOk },
+                { configured: hasAccessRestrictions, allowed: memberAllowed },
+            ]
+            : [{ configured: hasAccessRestrictions, allowed: memberAllowed }];
+        commandAuthorized = resolveCommandAuthorizedFromAuthorizers({
+            useAccessGroups,
+            authorizers,
+            modeWhenAccessGroupsOff: "configured",
+        });
+        if (!commandAuthorized) {
+            await respond("You are not authorized to use this command.", { ephemeral: true });
+            return;
+        }
+    }
+    if (isGroupDm && discordConfig?.dm?.groupEnabled === false) {
+        await respond("Discord group DMs are disabled.");
+        return;
+    }
+    const menu = resolveCommandArgMenu({
+        command,
+        args: commandArgs,
+        cfg,
+    });
+    if (menu) {
+        const menuPayload = buildDiscordCommandArgMenu({
+            command,
+            menu,
+            interaction: interaction,
+            cfg,
+            discordConfig,
+            accountId,
+            sessionPrefix,
+            threadBindings,
+        });
+        if (preferFollowUp) {
+            await safeDiscordInteractionCall("interaction follow-up", () => interaction.followUp({
+                content: menuPayload.content,
+                components: menuPayload.components,
+                ephemeral: true,
+            }));
+            return;
+        }
+        await safeDiscordInteractionCall("interaction reply", () => interaction.reply({
+            content: menuPayload.content,
+            components: menuPayload.components,
+            ephemeral: true,
+        }));
+        return;
+    }
+    const pluginMatch = matchPluginCommand(prompt);
+    if (pluginMatch) {
+        if (suppressReplies) {
+            return;
+        }
+        const channelId = rawChannelId || "unknown";
+        const pluginReply = await executePluginCommand({
+            command: pluginMatch.command,
+            args: pluginMatch.args,
+            senderId: sender.id,
+            channel: "discord",
+            channelId,
+            isAuthorizedSender: commandAuthorized,
+            commandBody: prompt,
+            config: cfg,
+            from: isDirectMessage
+                ? `discord:${user.id}`
+                : isGroupDm
+                    ? `discord:group:${channelId}`
+                    : `discord:channel:${channelId}`,
+            to: `slash:${user.id}`,
+            accountId,
+        });
+        if (!hasRenderableReplyPayload(pluginReply)) {
+            await respond("Done.");
+            return;
+        }
+        await deliverDiscordInteractionReply({
+            interaction,
+            payload: pluginReply,
+            textLimit: resolveTextChunkLimit(cfg, "discord", accountId, {
+                fallbackLimit: 2000,
+            }),
+            maxLinesPerMessage: discordConfig?.maxLinesPerMessage,
+            preferFollowUp,
+            chunkMode: resolveChunkMode(cfg, "discord", accountId),
+        });
+        return;
+    }
+    const pickerCommandContext = shouldOpenDiscordModelPickerFromCommand({
+        command,
+        commandArgs,
+    });
+    if (pickerCommandContext) {
+        await replyWithDiscordModelPickerProviders({
+            interaction,
+            cfg,
+            command: pickerCommandContext,
+            userId: user.id,
+            accountId,
+            threadBindings,
+            preferFollowUp,
+        });
+        return;
+    }
+    const isGuild = Boolean(interaction.guild);
+    const channelId = rawChannelId || "unknown";
+    const interactionId = interaction.rawData.id;
+    const route = resolveAgentRoute({
+        cfg,
+        channel: "discord",
+        accountId,
+        guildId: interaction.guild?.id ?? undefined,
+        memberRoleIds,
+        peer: {
+            kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+            id: isDirectMessage ? user.id : channelId,
+        },
+        parentPeer: threadParentId ? { kind: "channel", id: threadParentId } : undefined,
+    });
+    const threadBinding = isThreadChannel ? threadBindings.getByThreadId(rawChannelId) : undefined;
+    const configuredRoute = threadBinding == null
+        ? resolveConfiguredAcpRoute({
+            cfg,
+            route,
+            channel: "discord",
+            accountId,
+            conversationId: channelId,
+            parentConversationId: threadParentId,
+        })
+        : null;
+    const configuredBinding = configuredRoute?.configuredBinding ?? null;
+    if (configuredBinding) {
+        const ensured = await ensureConfiguredAcpRouteReady({
+            cfg,
+            configuredBinding,
+        });
+        if (!ensured.ok) {
+            logVerbose(`discord native command: configured ACP binding unavailable for channel ${configuredBinding.spec.conversationId}: ${ensured.error}`);
+            await respond("Configured ACP binding is unavailable right now. Please try again.");
+            return;
+        }
+    }
+    const configuredBoundSessionKey = configuredRoute?.boundSessionKey ?? "";
+    const boundSessionKey = threadBinding?.targetSessionKey?.trim() || configuredBoundSessionKey;
+    const boundAgentId = boundSessionKey ? resolveAgentIdFromSessionKey(boundSessionKey) : undefined;
+    const effectiveRoute = boundSessionKey
+        ? {
+            ...route,
+            sessionKey: boundSessionKey,
+            agentId: boundAgentId ?? route.agentId,
+            ...(configuredBinding ? { matchedBy: "binding.channel" } : {}),
+        }
+        : (configuredRoute?.route ?? route);
+    const conversationLabel = isDirectMessage ? (user.globalName ?? user.username) : channelId;
+    const ownerAllowFrom = resolveDiscordOwnerAllowFrom({
+        channelConfig,
+        guildInfo,
+        sender: { id: sender.id, name: sender.name, tag: sender.tag },
+        allowNameMatching,
+    });
+    const ctxPayload = finalizeInboundContext({
+        Body: prompt,
+        BodyForAgent: prompt,
+        RawBody: prompt,
+        CommandBody: prompt,
+        CommandArgs: commandArgs,
+        From: isDirectMessage
+            ? `discord:${user.id}`
+            : isGroupDm
+                ? `discord:group:${channelId}`
+                : `discord:channel:${channelId}`,
+        To: `slash:${user.id}`,
+        SessionKey: boundSessionKey ?? `agent:${effectiveRoute.agentId}:${sessionPrefix}:${user.id}`,
+        CommandTargetSessionKey: boundSessionKey ?? effectiveRoute.sessionKey,
+        AccountId: effectiveRoute.accountId,
+        ChatType: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+        ConversationLabel: conversationLabel,
+        GroupSubject: isGuild ? interaction.guild?.name : undefined,
+        GroupSystemPrompt: isGuild
+            ? (() => {
+                const systemPromptParts = [channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
+                return systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
+            })()
+            : undefined,
+        UntrustedContext: isGuild
+            ? (() => {
+                const channelTopic = channel && "topic" in channel ? (channel.topic ?? undefined) : undefined;
+                const untrustedChannelMetadata = buildUntrustedChannelMetadata({
+                    source: "discord",
+                    label: "Discord channel topic",
+                    entries: [channelTopic],
+                });
+                return untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined;
+            })()
+            : undefined,
+        OwnerAllowFrom: ownerAllowFrom,
+        SenderName: user.globalName ?? user.username,
+        SenderId: user.id,
+        SenderUsername: user.username,
+        SenderTag: sender.tag,
+        Provider: "discord",
+        Surface: "discord",
+        WasMentioned: true,
+        MessageSid: interactionId,
+        MessageThreadId: isThreadChannel ? channelId : undefined,
+        Timestamp: Date.now(),
+        CommandAuthorized: commandAuthorized,
+        CommandSource: "native",
+        // 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",
+        OriginatingTo: isDirectMessage ? `user:${user.id}` : `channel:${channelId}`,
+        ThreadParentId: isThreadChannel ? threadParentId : undefined,
+    });
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg,
+        agentId: effectiveRoute.agentId,
+        channel: "discord",
+        accountId: effectiveRoute.accountId,
+    });
+    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, effectiveRoute.agentId);
+    let didReply = false;
+    const dispatchResult = await dispatchReplyWithDispatcher({
+        ctx: ctxPayload,
+        cfg,
+        dispatcherOptions: {
+            ...prefixOptions,
+            humanDelay: resolveHumanDelayConfig(cfg, effectiveRoute.agentId),
+            deliver: async (payload) => {
+                if (suppressReplies) {
+                    return;
+                }
+                try {
+                    await deliverDiscordInteractionReply({
+                        interaction,
+                        payload,
+                        mediaLocalRoots,
+                        textLimit: resolveTextChunkLimit(cfg, "discord", accountId, {
+                            fallbackLimit: 2000,
+                        }),
+                        maxLinesPerMessage: discordConfig?.maxLinesPerMessage,
+                        preferFollowUp: preferFollowUp || didReply,
+                        chunkMode: resolveChunkMode(cfg, "discord", accountId),
+                    });
+                }
+                catch (error) {
+                    if (isDiscordUnknownInteraction(error)) {
+                        logVerbose("discord: interaction reply skipped (interaction expired)");
+                        return;
+                    }
+                    throw error;
+                }
+                didReply = true;
+            },
+            onError: (err, info) => {
+                const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+                log.error(`discord slash ${info.kind} reply failed: ${message}`);
+            },
+        },
+        replyOptions: {
+            skillFilter: channelConfig?.skills,
+            disableBlockStreaming: typeof discordConfig?.blockStreaming === "boolean"
+                ? !discordConfig.blockStreaming
+                : undefined,
+            onModelSelected,
+        },
+    });
+    // Fallback: if the agent turn produced no deliverable replies (for example,
+    // a skill only used message.send side effects), close the interaction with
+    // a minimal acknowledgment so Discord does not stay in a pending state.
+    if (!suppressReplies &&
+        !didReply &&
+        dispatchResult.counts.final === 0 &&
+        dispatchResult.counts.block === 0 &&
+        dispatchResult.counts.tool === 0) {
+        await safeDiscordInteractionCall("interaction empty fallback", async () => {
+            const payload = {
+                content: "✅ Done.",
+                ephemeral: true,
+            };
+            if (preferFollowUp) {
+                await interaction.followUp(payload);
+                return;
+            }
+            await interaction.reply(payload);
+        });
+    }
+}
+async function deliverDiscordInteractionReply(params) {
+    const { interaction, payload, textLimit, maxLinesPerMessage, preferFollowUp, chunkMode } = params;
+    const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+    const text = payload.text ?? "";
+    let hasReplied = false;
+    const sendMessage = async (content, files) => {
+        const payload = files && files.length > 0
+            ? {
+                content,
+                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]) };
+                }),
+            }
+            : { content };
+        await safeDiscordInteractionCall("interaction send", async () => {
+            if (!preferFollowUp && !hasReplied) {
+                await interaction.reply(payload);
+                hasReplied = true;
+                return;
+            }
+            await interaction.followUp(payload);
+            hasReplied = true;
+        });
+    };
+    if (mediaList.length > 0) {
+        const media = await Promise.all(mediaList.map(async (url) => {
+            const loaded = await loadWebMedia(url, {
+                localRoots: params.mediaLocalRoots,
+            });
+            return {
+                name: loaded.fileName ?? "upload",
+                data: loaded.buffer,
+            };
+        }));
+        const chunks = chunkDiscordTextWithMode(text, {
+            maxChars: textLimit,
+            maxLines: maxLinesPerMessage,
+            chunkMode,
+        });
+        if (!chunks.length && text) {
+            chunks.push(text);
+        }
+        const caption = chunks[0] ?? "";
+        await sendMessage(caption, media);
+        for (const chunk of chunks.slice(1)) {
+            if (!chunk.trim()) {
+                continue;
+            }
+            await interaction.followUp({ content: chunk });
+        }
+        return;
+    }
+    if (!text.trim()) {
+        return;
+    }
+    const chunks = chunkDiscordTextWithMode(text, {
+        maxChars: textLimit,
+        maxLines: maxLinesPerMessage,
+        chunkMode,
+    });
+    if (!chunks.length && text) {
+        chunks.push(text);
+    }
+    for (const chunk of chunks) {
+        if (!chunk.trim()) {
+            continue;
+        }
+        await sendMessage(chunk);
+    }
+}
+//# sourceMappingURL=native-command.js.map