@poolzin/pool-bot 2026.2.25 → 2026.2.26

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

@@ -1,24 +1,33 @@
-import { Button, ChannelType, Command, Row, } from "@buape/carbon";
+import { Button, ChannelType, Command, Container, Row, StringSelectMenu, TextDisplay, } from "@buape/carbon";
 import { ApplicationCommandOptionType, ButtonStyle } from "discord-api-types/v10";
 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 { 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 { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.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 { allowListMatches, isDiscordGroupAllowedByPolicy, normalizeDiscordAllowList, normalizeDiscordSlug, resolveDiscordChannelConfigWithFallback, resolveDiscordGuildEntry, resolveDiscordMemberAccessState, resolveDiscordOwnerAllowFrom, } from "./allow-list.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;
@@ -132,7 +141,7 @@ async function safeDiscordInteractionCall(label, fn) {
     }
     catch (error) {
         if (isDiscordUnknownInteraction(error)) {
-            console.warn(`discord: ${label} skipped (interaction expired)`);
+            logVerbose(`discord: ${label} skipped (interaction expired)`);
             return null;
         }
         throw error;
@@ -165,6 +174,486 @@ function parseDiscordCommandArgData(data) {
         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) {
@@ -187,11 +676,11 @@ async function handleDiscordCommandArgInteraction(interaction, data, ctx) {
         }));
         return;
     }
-    const updated = await safeDiscordInteractionCall("command arg update", () => interaction.update({
+    const argUpdateResult = await safeDiscordInteractionCall("command arg update", () => interaction.update({
         content: `✅ Selected ${parsed.value}.`,
         components: [],
     }));
-    if (!updated) {
+    if (argUpdateResult === null) {
         return;
     }
     const commandArgs = createCommandArgsWithValue({
@@ -213,6 +702,7 @@ async function handleDiscordCommandArgInteraction(interaction, data, ctx) {
         accountId: ctx.accountId,
         sessionPrefix: ctx.sessionPrefix,
         preferFollowUp: true,
+        threadBindings: ctx.threadBindings,
     });
 }
 class DiscordCommandArgButton extends Button {
@@ -223,6 +713,7 @@ class DiscordCommandArgButton extends Button {
     discordConfig;
     accountId;
     sessionPrefix;
+    threadBindings;
     constructor(params) {
         super();
         this.label = params.label;
@@ -231,6 +722,7 @@ class DiscordCommandArgButton extends Button {
         this.discordConfig = params.discordConfig;
         this.accountId = params.accountId;
         this.sessionPrefix = params.sessionPrefix;
+        this.threadBindings = params.threadBindings;
     }
     async run(interaction, data) {
         await handleDiscordCommandArgInteraction(interaction, data, {
@@ -238,6 +730,7 @@ class DiscordCommandArgButton extends Button {
             discordConfig: this.discordConfig,
             accountId: this.accountId,
             sessionPrefix: this.sessionPrefix,
+            threadBindings: this.threadBindings,
         });
     }
 }
@@ -256,6 +749,36 @@ class DiscordCommandArgFallbackButton extends Button {
 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;
@@ -273,6 +796,7 @@ function buildDiscordCommandArgMenu(params) {
             discordConfig: params.discordConfig,
             accountId: params.accountId,
             sessionPrefix: params.sessionPrefix,
+            threadBindings: params.threadBindings,
         }));
         return new Row(buttons);
     });
@@ -280,7 +804,7 @@ function buildDiscordCommandArgMenu(params) {
     return { content, components: rows };
 }
 export function createDiscordNativeCommand(params) {
-    const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault } = params;
+    const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings, } = params;
     const commandDefinition = findCommandByNativeName(command.name, "discord") ??
         {
             key: command.name,
@@ -338,12 +862,13 @@ export function createDiscordNativeCommand(params) {
                 accountId,
                 sessionPrefix,
                 preferFollowUp: false,
+                threadBindings,
             });
         }
     })();
 }
 async function dispatchDiscordCommandInteraction(params) {
-    const { interaction, prompt, command, commandArgs, cfg, discordConfig, accountId, sessionPrefix, preferFollowUp, } = params;
+    const { interaction, prompt, command, commandArgs, cfg, discordConfig, accountId, sessionPrefix, preferFollowUp, threadBindings, suppressReplies, } = params;
     const respond = async (content, options) => {
         const payload = {
             content,
@@ -451,7 +976,7 @@ async function dispatchDiscordCommandInteraction(params) {
             return;
         }
         if (dmPolicy !== "open") {
-            const storeAllowFrom = await readChannelAllowFromStore("discord").catch(() => []);
+            const storeAllowFrom = dmPolicy === "allowlist" ? [] : await readChannelAllowFromStore("discord").catch(() => []);
             const effectiveAllowFrom = [
                 ...(discordConfig?.allowFrom ?? discordConfig?.dm?.allowFrom ?? []),
                 ...storeAllowFrom,
@@ -532,6 +1057,7 @@ async function dispatchDiscordCommandInteraction(params) {
             discordConfig,
             accountId,
             sessionPrefix,
+            threadBindings,
         });
         if (preferFollowUp) {
             await safeDiscordInteractionCall("interaction follow-up", () => interaction.followUp({
@@ -548,6 +1074,22 @@ async function dispatchDiscordCommandInteraction(params) {
         }));
         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;
@@ -563,6 +1105,16 @@ async function dispatchDiscordCommandInteraction(params) {
         },
         parentPeer: threadParentId ? { kind: "channel", id: threadParentId } : undefined,
     });
+    const threadBinding = isThreadChannel ? threadBindings.getByThreadId(rawChannelId) : undefined;
+    const boundSessionKey = threadBinding?.targetSessionKey?.trim();
+    const boundAgentId = boundSessionKey ? resolveAgentIdFromSessionKey(boundSessionKey) : undefined;
+    const effectiveRoute = boundSessionKey
+        ? {
+            ...route,
+            sessionKey: boundSessionKey,
+            agentId: boundAgentId ?? route.agentId,
+        }
+        : route;
     const conversationLabel = isDirectMessage ? (user.globalName ?? user.username) : channelId;
     const ownerAllowFrom = resolveDiscordOwnerAllowFrom({
         channelConfig,
@@ -581,9 +1133,9 @@ async function dispatchDiscordCommandInteraction(params) {
                 ? `discord:group:${channelId}`
                 : `discord:channel:${channelId}`,
         To: `slash:${user.id}`,
-        SessionKey: `agent:${route.agentId}:${sessionPrefix}:${user.id}`,
-        CommandTargetSessionKey: route.sessionKey,
-        AccountId: route.accountId,
+        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,
@@ -613,6 +1165,7 @@ async function dispatchDiscordCommandInteraction(params) {
         Surface: "discord",
         WasMentioned: true,
         MessageSid: interactionId,
+        MessageThreadId: isThreadChannel ? channelId : undefined,
         Timestamp: Date.now(),
         CommandAuthorized: commandAuthorized,
         CommandSource: "native",
@@ -624,19 +1177,22 @@ async function dispatchDiscordCommandInteraction(params) {
     });
     const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
         cfg,
-        agentId: route.agentId,
+        agentId: effectiveRoute.agentId,
         channel: "discord",
-        accountId: route.accountId,
+        accountId: effectiveRoute.accountId,
     });
-    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
+    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, effectiveRoute.agentId);
     let didReply = false;
     await dispatchReplyWithDispatcher({
         ctx: ctxPayload,
         cfg,
         dispatcherOptions: {
             ...prefixOptions,
-            humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
+            humanDelay: resolveHumanDelayConfig(cfg, effectiveRoute.agentId),
             deliver: async (payload) => {
+                if (suppressReplies) {
+                    return;
+                }
                 try {
                     await deliverDiscordInteractionReply({
                         interaction,
@@ -652,7 +1208,7 @@ async function dispatchDiscordCommandInteraction(params) {
                 }
                 catch (error) {
                     if (isDiscordUnknownInteraction(error)) {
-                        console.warn("discord: interaction reply skipped (interaction expired)");
+                        logVerbose("discord: interaction reply skipped (interaction expired)");
                         return;
                     }
                     throw error;
@@ -660,7 +1216,8 @@ async function dispatchDiscordCommandInteraction(params) {
                 didReply = true;
             },
             onError: (err, info) => {
-                console.error(`discord slash ${info.kind} reply failed`, err);
+                const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+                log.error(`discord slash ${info.kind} reply failed: ${message}`);
             },
         },
         replyOptions: {