@otto-assistant/otto 0.7.16 → 0.7.17

package/dist/commands/model-variant.js

@@ -5,7 +5,7 @@
 // Cross-menu state: Discord doesn't expose already-selected values on sibling
 // select menus in the same message. We track partial selections in the context
 // Map. Whichever menu fires second sees the first selection stored and applies.
-import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, ButtonInteraction, StringSelectMenuBuilder, ButtonBuilder, ButtonStyle, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { setChannelModel, setSessionModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
@@ -313,21 +313,20 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 variant,
             });
             logger.log(`Set variant ${variant ?? 'none'} for session ${context.sessionId} (model ${modelId})`);
-            let retried = false;
-            if (context.thread) {
-                const runtime = getRuntime(context.thread.id);
-                if (runtime) {
-                    retried = await runtime.retryLastUserPrompt();
-                }
-            }
-            const retryNote = retried
-                ? '\n_Restarting current request with new variant..._'
-                : '';
+            // Show a button so the user can choose to resend the last message.
+            // Do not auto-retry — the user may want to add context in a new message instead.
+            // Context is kept alive (TTL handles cleanup) so the button can access it.
+            const retryButton = new ButtonBuilder()
+                .setCustomId(`variant_retry:${contextHash}`)
+                .setLabel('Resend last message')
+                .setStyle(ButtonStyle.Secondary);
+            const actionRow = new ActionRowBuilder().addComponents(retryButton);
             await interaction.editReply({
-                content: `Variant set for this session:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
+                content: `Variant set for this session:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
-                components: [],
+                components: [actionRow],
             });
+            return;
         }
         else if (scope === 'global') {
             await setGlobalModel({ appId: context.appId, modelId, variant });
@@ -357,7 +356,11 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 components: [],
             });
         }
-        pendingVariantContexts.delete(contextHash);
+        // Clean up the context from memory, except for session scope where the
+        // retry button still needs it. TTL handles cleanup in that case.
+        if (scope !== 'session') {
+            pendingVariantContexts.delete(contextHash);
+        }
     }
     catch (error) {
         logger.error('Error applying variant:', error);
@@ -367,3 +370,41 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
         });
     }
 }
+/**
+ * Handle the "Resend last message" button shown after a session-scope variant change.
+ * Aborts any active run and resends the last user prompt with the new variant.
+ */
+export async function handleVariantRetryButton(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('variant_retry:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('variant_retry:', '');
+    const context = pendingVariantContexts.get(contextHash);
+    // Context may have expired (TTL) — still allow the action via runtime alone.
+    const threadId = context?.thread?.id;
+    if (!threadId) {
+        await interaction.editReply({
+            content: 'Could not find the session thread. Please resend your message manually.',
+            components: [],
+        });
+        return;
+    }
+    const runtime = getRuntime(threadId);
+    if (!runtime) {
+        await interaction.editReply({
+            content: 'No active session found. Please resend your message manually.',
+            components: [],
+        });
+        return;
+    }
+    const retried = await runtime.retryLastUserPrompt();
+    pendingVariantContexts.delete(contextHash);
+    await interaction.editReply({
+        content: retried
+            ? `Restarting with new variant...`
+            : `Variant changed. Send a new message to continue.`,
+        components: [],
+    });
+}

package/dist/commands/model.js

@@ -1,5 +1,5 @@
 // /model command - Set the preferred model for this channel or session.
-import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, ButtonInteraction, StringSelectMenuBuilder, ButtonBuilder, ButtonStyle, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { setChannelModel, setSessionModel, setSessionAgent, getChannelModel, getSessionModel, getSessionAgent, getChannelAgent, getThreadSession, getGlobalModel, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
@@ -741,21 +741,20 @@ export async function handleModelScopeSelectMenu(interaction) {
             }
             await setSessionModel({ sessionId: context.sessionId, modelId, variant });
             modelLogger.log(`Set model ${modelId}${variantSuffix} for session ${context.sessionId}`);
-            let retried = false;
-            if (context.thread) {
-                const runtime = getRuntime(context.thread.id);
-                if (runtime) {
-                    retried = await runtime.retryLastUserPrompt();
-                }
-            }
-            const retryNote = retried
-                ? '\n_Restarting current request with new model..._'
-                : '';
+            // Show a button so the user can choose to resend the last message.
+            // Do not auto-retry — the user may want to add context in a new message instead.
+            // Context is kept alive (TTL handles cleanup) so the button can access it.
+            const retryButton = new ButtonBuilder()
+                .setCustomId(`model_retry:${contextHash}`)
+                .setLabel('Resend last message')
+                .setStyle(ButtonStyle.Secondary);
+            const actionRow = new ActionRowBuilder().addComponents(retryButton);
             await interaction.editReply({
-                content: `Model set for this session:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
+                content: `Model set for this session:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
-                components: [],
+                components: [actionRow],
             });
+            return;
         }
         else if (selectedScope === 'global') {
             if (!context.appId) {
@@ -785,8 +784,11 @@ export async function handleModelScopeSelectMenu(interaction) {
                 components: [],
             });
         }
-        // Clean up the context from memory
-        deleteModelContext(contextHash);
+        // Clean up the context from memory, except for session scope where the
+        // retry button still needs it. TTL handles cleanup in that case.
+        if (selectedScope !== 'session') {
+            deleteModelContext(contextHash);
+        }
     }
     catch (error) {
         modelLogger.error('Error saving model preference:', error);
@@ -796,3 +798,41 @@ export async function handleModelScopeSelectMenu(interaction) {
         });
     }
 }
+/**
+ * Handle the "Resend last message" button shown after a session-scope model change.
+ * Aborts any active run and resends the last user prompt with the new model.
+ */
+export async function handleModelRetryButton(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('model_retry:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('model_retry:', '');
+    const context = pendingModelContexts.get(contextHash);
+    // Context may have expired (10 min TTL) — still allow the action via runtime alone.
+    const threadId = context?.thread?.id;
+    if (!threadId) {
+        await interaction.editReply({
+            content: 'Could not find the session thread. Please resend your message manually.',
+            components: [],
+        });
+        return;
+    }
+    const runtime = getRuntime(threadId);
+    if (!runtime) {
+        await interaction.editReply({
+            content: 'No active session found. Please resend your message manually.',
+            components: [],
+        });
+        return;
+    }
+    const retried = await runtime.retryLastUserPrompt();
+    deleteModelContext(contextHash);
+    await interaction.editReply({
+        content: retried
+            ? `Restarting with new model...`
+            : `Model changed. Send a new message to continue.`,
+        components: [],
+    });
+}

package/dist/commands/unset-model.js

@@ -1,5 +1,5 @@
 // /unset-model-override command - Remove model overrides and use default instead.
-import { ChatInputCommandInteraction, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, ButtonInteraction, ButtonBuilder, ButtonStyle, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import { getChannelModel, getSessionModel, getThreadSession, clearSessionModel, } from '../database.js';
 import { getPrisma } from '../db.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
@@ -121,19 +121,58 @@ export async function handleUnsetModelCommand({ interaction, appId, }) {
                 ? 'none'
                 : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, 'agentName' in newModelInfo ? newModelInfo.agentName : undefined)})`;
     }
-    // Check if there's a running request and abort+retry with new model (only for session changes in threads)
-    let retried = false;
+    const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel';
+    // Show a button so the user can choose to resend the last message (session scope only).
+    // Do not auto-retry — the user may want to add context in a new message instead.
     if (isThread && clearedType === 'session' && sessionId) {
         const runtime = getRuntime(channel.id);
         if (runtime) {
-            retried = await runtime.retryLastUserPrompt();
+            const retryButton = new ButtonBuilder()
+                .setCustomId(`unset_model_retry:${channel.id}`)
+                .setLabel('Resend last message')
+                .setStyle(ButtonStyle.Secondary);
+            const actionRow = new ActionRowBuilder().addComponents(retryButton);
+            await interaction.editReply({
+                content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}`,
+                components: [actionRow],
+            });
+            return;
         }
     }
-    const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel';
-    const retriedText = retried
-        ? '\n_Restarting current request with new model..._'
-        : '';
     await interaction.editReply({
-        content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}${retriedText}`,
+        content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}`,
+    });
+}
+/**
+ * Handle the "Resend last message" button after clearing a session model override.
+ */
+export async function handleUnsetModelRetryButton(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('unset_model_retry:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const threadId = customId.replace('unset_model_retry:', '');
+    if (!threadId) {
+        await interaction.editReply({
+            content: 'Could not find the session. Please resend your message manually.',
+            components: [],
+        });
+        return;
+    }
+    const runtime = getRuntime(threadId);
+    if (!runtime) {
+        await interaction.editReply({
+            content: 'No active session found. Please resend your message manually.',
+            components: [],
+        });
+        return;
+    }
+    const retried = await runtime.retryLastUserPrompt();
+    await interaction.editReply({
+        content: retried
+            ? 'Restarting with new model...'
+            : 'Model changed. Send a new message to continue.',
+        components: [],
     });
 }

package/dist/interaction-handler.js

@@ -21,8 +21,8 @@ import { handleDiffCommand } from './commands/diff.js';
 import { handleForkCommand, handleForkSelectMenu, } from './commands/fork.js';
 import { handleForkSubagentCommand, handleForkSubagentSelectMenu, } from './commands/fork-subagent.js';
 import { handleBtwCommand } from './commands/btw.js';
-import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, handleModelScopeSelectMenu, } from './commands/model.js';
-import { handleUnsetModelCommand } from './commands/unset-model.js';
+import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, handleModelScopeSelectMenu, handleModelRetryButton, } from './commands/model.js';
+import { handleUnsetModelCommand, handleUnsetModelRetryButton, } from './commands/unset-model.js';
 import { handleLoginCommand, handleLoginSelect, handleLoginTextButton, handleLoginTextModalSubmit, handleLoginApiKeyButton, handleOAuthCodeButton, handleOAuthCodeModalSubmit, handleApiKeyModalSubmit, } from './commands/login.js';
 import { handleTranscriptionApiKeyButton, handleTranscriptionApiKeyCommand, handleTranscriptionApiKeyModalSubmit, } from './commands/gemini-apikey.js';
 import { handleAgentCommand, handleAgentSelectMenu, handleQuickAgentCommand, } from './commands/agent.js';
@@ -44,7 +44,7 @@ import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
 import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
 import { handleVscodeCommand } from './commands/vscode.js';
 import { handleModelVariantSelectMenu } from './commands/model.js';
-import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
+import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, handleVariantRetryButton, } from './commands/model-variant.js';
 import { hasOttoBotPermission } from './discord-utils.js';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -302,6 +302,18 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     await handleHtmlActionButton(interaction);
                     return;
                 }
+                if (customId.startsWith('model_retry:')) {
+                    await handleModelRetryButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('variant_retry:')) {
+                    await handleVariantRetryButton(interaction);
+                    return;
+                }
+                if (customId.startsWith('unset_model_retry:')) {
+                    await handleUnsetModelRetryButton(interaction);
+                    return;
+                }
                 return;
             }
             if (interaction.isStringSelectMenu()) {

package/package.json

@@ -7,7 +7,7 @@
   },
   "module": "index.ts",
   "type": "module",
-  "version": "0.7.16",
+  "version": "0.7.17",
   "scripts": {
     "dev": "tsx src/bin.ts",
     "prepublishOnly": "pnpm build",

package/src/commands/model-variant.ts

@@ -9,7 +9,10 @@
 import {
   ChatInputCommandInteraction,
   StringSelectMenuInteraction,
+  ButtonInteraction,
   StringSelectMenuBuilder,
+  ButtonBuilder,
+  ButtonStyle,
   ActionRowBuilder,
   ChannelType,
   type ThreadChannel,
@@ -427,22 +430,22 @@ async function applyVariant({
         `Set variant ${variant ?? 'none'} for session ${context.sessionId} (model ${modelId})`,
       )
 
-      let retried = false
-      if (context.thread) {
-        const runtime = getRuntime(context.thread.id)
-        if (runtime) {
-          retried = await runtime.retryLastUserPrompt()
-        }
-      }
+      // Show a button so the user can choose to resend the last message.
+      // Do not auto-retry — the user may want to add context in a new message instead.
+      // Context is kept alive (TTL handles cleanup) so the button can access it.
+      const retryButton = new ButtonBuilder()
+        .setCustomId(`variant_retry:${contextHash}`)
+        .setLabel('Resend last message')
+        .setStyle(ButtonStyle.Secondary)
+
+      const actionRow = new ActionRowBuilder<ButtonBuilder>().addComponents(retryButton)
 
-      const retryNote = retried
-        ? '\n_Restarting current request with new variant..._'
-        : ''
       await interaction.editReply({
-        content: `Variant set for this session:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
+        content: `Variant set for this session:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`${agentTip}`,
         flags: MessageFlags.SuppressEmbeds,
-        components: [],
+        components: [actionRow],
       })
+      return
     } else if (scope === 'global') {
       await setGlobalModel({ appId: context.appId, modelId, variant })
       await setChannelModel({
@@ -477,7 +480,11 @@ async function applyVariant({
       })
     }
 
-    pendingVariantContexts.delete(contextHash)
+    // Clean up the context from memory, except for session scope where the
+    // retry button still needs it. TTL handles cleanup in that case.
+    if (scope !== 'session') {
+      pendingVariantContexts.delete(contextHash)
+    }
   } catch (error) {
     logger.error('Error applying variant:', error)
     await interaction.editReply({
@@ -486,3 +493,51 @@ async function applyVariant({
     })
   }
 }
+
+/**
+ * Handle the "Resend last message" button shown after a session-scope variant change.
+ * Aborts any active run and resends the last user prompt with the new variant.
+ */
+export async function handleVariantRetryButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('variant_retry:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('variant_retry:', '')
+  const context = pendingVariantContexts.get(contextHash)
+
+  // Context may have expired (TTL) — still allow the action via runtime alone.
+  const threadId = context?.thread?.id
+
+  if (!threadId) {
+    await interaction.editReply({
+      content: 'Could not find the session thread. Please resend your message manually.',
+      components: [],
+    })
+    return
+  }
+
+  const runtime = getRuntime(threadId)
+  if (!runtime) {
+    await interaction.editReply({
+      content: 'No active session found. Please resend your message manually.',
+      components: [],
+    })
+    return
+  }
+
+  const retried = await runtime.retryLastUserPrompt()
+  pendingVariantContexts.delete(contextHash)
+
+  await interaction.editReply({
+    content: retried
+      ? `Restarting with new variant...`
+      : `Variant changed. Send a new message to continue.`,
+    components: [],
+  })
+}

package/src/commands/model.ts

@@ -3,7 +3,10 @@
 import {
   ChatInputCommandInteraction,
   StringSelectMenuInteraction,
+  ButtonInteraction,
   StringSelectMenuBuilder,
+  ButtonBuilder,
+  ButtonStyle,
   ActionRowBuilder,
   ChannelType,
   type ThreadChannel,
@@ -1020,22 +1023,22 @@ export async function handleModelScopeSelectMenu(
         `Set model ${modelId}${variantSuffix} for session ${context.sessionId}`,
       )
 
-      let retried = false
-      if (context.thread) {
-        const runtime = getRuntime(context.thread.id)
-        if (runtime) {
-          retried = await runtime.retryLastUserPrompt()
-        }
-      }
+      // Show a button so the user can choose to resend the last message.
+      // Do not auto-retry — the user may want to add context in a new message instead.
+      // Context is kept alive (TTL handles cleanup) so the button can access it.
+      const retryButton = new ButtonBuilder()
+        .setCustomId(`model_retry:${contextHash}`)
+        .setLabel('Resend last message')
+        .setStyle(ButtonStyle.Secondary)
+
+      const actionRow = new ActionRowBuilder<ButtonBuilder>().addComponents(retryButton)
 
-      const retryNote = retried
-        ? '\n_Restarting current request with new model..._'
-        : ''
       await interaction.editReply({
-        content: `Model set for this session:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
+        content: `Model set for this session:\n**${context.providerName}** / **${modelDisplay}**${variantSuffix}\n\`${modelId}\`${agentTip}`,
         flags: MessageFlags.SuppressEmbeds,
-        components: [],
+        components: [actionRow],
       })
+      return
     } else if (selectedScope === 'global') {
       if (!context.appId) {
         deleteModelContext(contextHash)
@@ -1070,8 +1073,11 @@ export async function handleModelScopeSelectMenu(
       })
     }
 
-    // Clean up the context from memory
-    deleteModelContext(contextHash)
+    // Clean up the context from memory, except for session scope where the
+    // retry button still needs it. TTL handles cleanup in that case.
+    if (selectedScope !== 'session') {
+      deleteModelContext(contextHash)
+    }
   } catch (error) {
     modelLogger.error('Error saving model preference:', error)
     await interaction.editReply({
@@ -1080,3 +1086,51 @@ export async function handleModelScopeSelectMenu(
     })
   }
 }
+
+/**
+ * Handle the "Resend last message" button shown after a session-scope model change.
+ * Aborts any active run and resends the last user prompt with the new model.
+ */
+export async function handleModelRetryButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('model_retry:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const contextHash = customId.replace('model_retry:', '')
+  const context = pendingModelContexts.get(contextHash)
+
+  // Context may have expired (10 min TTL) — still allow the action via runtime alone.
+  const threadId = context?.thread?.id
+
+  if (!threadId) {
+    await interaction.editReply({
+      content: 'Could not find the session thread. Please resend your message manually.',
+      components: [],
+    })
+    return
+  }
+
+  const runtime = getRuntime(threadId)
+  if (!runtime) {
+    await interaction.editReply({
+      content: 'No active session found. Please resend your message manually.',
+      components: [],
+    })
+    return
+  }
+
+  const retried = await runtime.retryLastUserPrompt()
+  deleteModelContext(contextHash)
+
+  await interaction.editReply({
+    content: retried
+      ? `Restarting with new model...`
+      : `Model changed. Send a new message to continue.`,
+    components: [],
+  })
+}

package/src/commands/unset-model.ts

@@ -2,6 +2,10 @@
 
 import {
   ChatInputCommandInteraction,
+  ButtonInteraction,
+  ButtonBuilder,
+  ButtonStyle,
+  ActionRowBuilder,
   ChannelType,
   type ThreadChannel,
   type TextChannel,
@@ -154,21 +158,69 @@ export async function handleUnsetModelCommand({
         : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, 'agentName' in newModelInfo ? newModelInfo.agentName : undefined)})`
   }
 
-  // Check if there's a running request and abort+retry with new model (only for session changes in threads)
-  let retried = false
+  const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel'
+  // Show a button so the user can choose to resend the last message (session scope only).
+  // Do not auto-retry — the user may want to add context in a new message instead.
   if (isThread && clearedType === 'session' && sessionId) {
     const runtime = getRuntime(channel.id)
     if (runtime) {
-      retried = await runtime.retryLastUserPrompt()
+      const retryButton = new ButtonBuilder()
+        .setCustomId(`unset_model_retry:${channel.id}`)
+        .setLabel('Resend last message')
+        .setStyle(ButtonStyle.Secondary)
+
+      const actionRow = new ActionRowBuilder<ButtonBuilder>().addComponents(retryButton)
+
+      await interaction.editReply({
+        content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}`,
+        components: [actionRow],
+      })
+      return
     }
   }
 
-  const clearedTypeText = clearedType === 'session' ? 'Session' : 'Channel'
-  const retriedText = retried
-    ? '\n_Restarting current request with new model..._'
-    : ''
+  await interaction.editReply({
+    content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}`,
+  })
+}
+
+/**
+ * Handle the "Resend last message" button after clearing a session model override.
+ */
+export async function handleUnsetModelRetryButton(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const customId = interaction.customId
+  if (!customId.startsWith('unset_model_retry:')) {
+    return
+  }
+
+  await interaction.deferUpdate()
+
+  const threadId = customId.replace('unset_model_retry:', '')
+  if (!threadId) {
+    await interaction.editReply({
+      content: 'Could not find the session. Please resend your message manually.',
+      components: [],
+    })
+    return
+  }
+
+  const runtime = getRuntime(threadId)
+  if (!runtime) {
+    await interaction.editReply({
+      content: 'No active session found. Please resend your message manually.',
+      components: [],
+    })
+    return
+  }
+
+  const retried = await runtime.retryLastUserPrompt()
 
   await interaction.editReply({
-    content: `${clearedTypeText} model override removed.\n**Was:** \`${clearedModel}\`\n**Now using:** ${newModelText}${retriedText}`,
+    content: retried
+      ? 'Restarting with new model...'
+      : 'Model changed. Send a new message to continue.',
+    components: [],
   })
 }

package/src/interaction-handler.ts

@@ -57,8 +57,12 @@ import {
   handleProviderSelectMenu,
   handleModelSelectMenu,
   handleModelScopeSelectMenu,
+  handleModelRetryButton,
 } from './commands/model.js'
-import { handleUnsetModelCommand } from './commands/unset-model.js'
+import {
+  handleUnsetModelCommand,
+  handleUnsetModelRetryButton,
+} from './commands/unset-model.js'
 import {
   handleLoginCommand,
   handleLoginSelect,
@@ -116,6 +120,7 @@ import {
   handleModelVariantCommand,
   handleVariantQuickSelectMenu,
   handleVariantScopeSelectMenu,
+  handleVariantRetryButton,
 } from './commands/model-variant.js'
 import { hasOttoBotPermission } from './discord-utils.js'
 import { createLogger, LogPrefix } from './logger.js'
@@ -463,6 +468,21 @@ export function registerInteractionHandler({
             return
           }
 
+          if (customId.startsWith('model_retry:')) {
+            await handleModelRetryButton(interaction)
+            return
+          }
+
+          if (customId.startsWith('variant_retry:')) {
+            await handleVariantRetryButton(interaction)
+            return
+          }
+
+          if (customId.startsWith('unset_model_retry:')) {
+            await handleUnsetModelRetryButton(interaction)
+            return
+          }
+
           return
         }