@otto-assistant/otto 0.7.15 → 0.7.17

package/dist/commands/discord-commands-group-a.test.js

@@ -429,6 +429,40 @@ describe('/model', () => {
       Select a provider:"
     `);
     });
+    test('shows provider list error details', async () => {
+        const textChannel = { id: 'channel-1', type: ChannelType.GuildText };
+        const { command } = createCommand({ channel: textChannel });
+        mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' });
+        mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+            return {
+                provider: {
+                    list: vi.fn(async () => {
+                        return {
+                            error: {
+                                name: 'UnknownError',
+                                data: {
+                                    message: 'Cursor token refresh failed: {"code":"internal","message":"Error"}',
+                                },
+                            },
+                        };
+                    }),
+                },
+            };
+        });
+        await handleModelCommand({
+            interaction: command,
+            appId: 'app-1',
+        });
+        expect(command.editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "Failed to fetch providers: Cursor token refresh failed: {"code":"internal","message":"Error"}",
+          },
+        ],
+      ]
+    `);
+    });
 });
 describe('/agent', () => {
     test('shows selectable agents and current channel override', async () => {

package/dist/commands/login.js

@@ -13,6 +13,7 @@ import crypto from 'node:crypto';
 import { initializeOpencodeForDirectory, getOpencodeServerPort, } from '../opencode.js';
 import { resolveTextChannel, getOttoMetadata } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { formatOpenCodeResponseError } from '../errors.js';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const loginLogger = createLogger(LogPrefix.LOGIN);
 // ── Context store ───────────────────────────────────────────────
@@ -141,7 +142,9 @@ export async function handleLoginCommand({ interaction, }) {
             directory: projectDirectory,
         });
         if (!providersResponse.data) {
-            await interaction.editReply({ content: 'Failed to fetch providers' });
+            await interaction.editReply({
+                content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+            });
             return;
         }
         const { all: allProviders, connected } = providersResponse.data;
@@ -272,7 +275,10 @@ async function handleProviderStep(interaction, ctx, hash, providerId) {
         }
         const providersResponse = await getClient().provider.list({ directory: ctx.dir });
         if (!providersResponse.data) {
-            await interaction.editReply({ content: 'Failed to fetch providers', components: [] });
+            await interaction.editReply({
+                content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+                components: [],
+            });
             return;
         }
         const { all: allProviders, connected } = providersResponse.data;

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';
@@ -14,6 +14,7 @@ import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, } from './model.
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { formatOpenCodeResponseError } from '../errors.js';
 const logger = createLogger(LogPrefix.MODEL);
 const pendingVariantContexts = new Map();
 /** 10 minute TTL for pending contexts to prevent unbounded map growth */
@@ -121,7 +122,9 @@ export async function handleModelVariantCommand({ interaction, appId, }) {
         return;
     }
     if (!providersResponse.data) {
-        await interaction.editReply({ content: 'Failed to fetch providers' });
+        await interaction.editReply({
+            content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+        });
         return;
     }
     const { providerID, modelID, model: fullModelId } = currentModelInfo;
@@ -310,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 });
@@ -354,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);
@@ -364,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';
@@ -8,6 +8,7 @@ import { getDefaultModel } from '../session-handler/model-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
+import { formatOpenCodeResponseError } from '../errors.js';
 import * as errore from 'errore';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const modelLogger = createLogger(LogPrefix.MODEL);
@@ -270,7 +271,7 @@ export async function handleModelCommand({ interaction, appId, }) {
         ]);
         if (!providersResponse.data) {
             await interaction.editReply({
-                content: 'Failed to fetch providers',
+                content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
             });
             return;
         }
@@ -393,7 +394,10 @@ export async function handleProviderSelectMenu(interaction) {
         }
         const providersResponse = await getClient().provider.list({ directory: context.dir });
         if (!providersResponse.data) {
-            await interaction.editReply({ content: 'Failed to fetch providers', components: [] });
+            await interaction.editReply({
+                content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+                components: [],
+            });
             return;
         }
         const { all: allProviders, connected } = providersResponse.data;
@@ -434,7 +438,7 @@ export async function handleProviderSelectMenu(interaction) {
         });
         if (!providersResponse.data) {
             await interaction.editReply({
-                content: 'Failed to fetch providers',
+                content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
                 components: [],
             });
             return;
@@ -737,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) {
@@ -781,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);
@@ -792,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/discord-bot.js

@@ -43,11 +43,11 @@ import * as errore from "errore";
 import { createLogger, formatErrorWithStack, LogPrefix } from "./logger.js";
 import { writeHeapSnapshot, startHeapMonitor } from "./heap-monitor.js";
 import { startTaskRunner } from "./task-runner.js";
+import { setGlobalDispatcher, Agent } from "undici";
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
 // Each session's event.subscribe() holds a connection; without enough connections,
 // regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
-// undici is a transitive dep from discord.js — not listed in our package.json.
-// Types are declared in src/undici.d.ts.
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const voiceLogger = createLogger(LogPrefix.VOICE);
 // Well-known WebSocket and Discord Gateway close codes for diagnostic logging.

package/dist/errors.js

@@ -155,3 +155,25 @@ export class GitCommandError extends createTaggedError({
     message: 'Git command failed: $command',
 }) {
 }
+export function formatOpenCodeResponseError(error) {
+    if (error && typeof error === 'object') {
+        if ('data' in error &&
+            error.data &&
+            typeof error.data === 'object' &&
+            'message' in error.data) {
+            return String(error.data.message);
+        }
+        if ('errors' in error &&
+            Array.isArray(error.errors) &&
+            error.errors.length > 0) {
+            return JSON.stringify(error.errors);
+        }
+        if ('message' in error && typeof error.message === 'string') {
+            return error.message;
+        }
+        if ('name' in error && typeof error.name === 'string') {
+            return error.name;
+        }
+    }
+    return 'Unknown OpenCode API error';
+}

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/dist/opencode.js

@@ -39,7 +39,7 @@ const STARTUP_STDERR_TAIL_LIMIT = 30;
 const STARTUP_STDERR_LINE_MAX_LENGTH = 120;
 const STARTUP_ERROR_REASON_MAX_LENGTH = 1500;
 const ANSI_ESCAPE_REGEX = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
-async function requestHealthcheck({ url, }) {
+async function requestHealthcheck({ url, timeoutMs = 2000, }) {
     return new Promise((resolve, reject) => {
         const req = http.request(url, {
             method: 'GET',
@@ -58,6 +58,13 @@ async function requestHealthcheck({ url, }) {
                 });
             });
         });
+        // Without a timeout, a stalled connection (TCP accepted during opencode
+        // startup before the HTTP layer is ready) hangs forever, wedging
+        // waitForServer on its first iteration and blocking the entire single
+        // server startup promise. Abort and let the poll loop retry instead.
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error(`healthcheck timed out after ${timeoutMs}ms`));
+        });
         req.on('error', reject);
         req.end();
     });

package/package.json

@@ -7,7 +7,7 @@
   },
   "module": "index.ts",
   "type": "module",
-  "version": "0.7.15",
+  "version": "0.7.17",
   "scripts": {
     "dev": "tsx src/bin.ts",
     "prepublishOnly": "pnpm build",
@@ -52,8 +52,7 @@
     "opencode-cached-provider": "workspace:^",
     "opencode-deterministic-provider": "workspace:^",
     "prisma": "7.4.2",
-    "tsx": "^4.20.5",
-    "undici": "^8.0.2"
+    "tsx": "^4.20.5"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.53",
@@ -88,6 +87,7 @@
     "proper-lockfile": "^4.1.2",
     "string-dedent": "^3.0.2",
     "traforo": "^0.4.0",
+    "undici": "^8.0.2",
     "ws": "^8.19.0",
     "xdg-basedir": "^5.1.0",
     "yaml": "^2.8.3",

package/src/commands/discord-commands-group-a.test.ts

@@ -512,6 +512,44 @@ describe('/model', () => {
     `,
     )
   })
+
+  test('shows provider list error details', async () => {
+    const textChannel = { id: 'channel-1', type: ChannelType.GuildText }
+    const { command } = createCommand({ channel: textChannel })
+
+    mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' })
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {
+        provider: {
+          list: vi.fn(async () => {
+            return {
+              error: {
+                name: 'UnknownError',
+                data: {
+                  message: 'Cursor token refresh failed: {"code":"internal","message":"Error"}',
+                },
+              },
+            }
+          }),
+        },
+      }
+    })
+
+    await handleModelCommand({
+      interaction: command as never,
+      appId: 'app-1',
+    })
+
+    expect(command.editReply.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "content": "Failed to fetch providers: Cursor token refresh failed: {"code":"internal","message":"Error"}",
+          },
+        ],
+      ]
+    `)
+  })
 })
 
 describe('/agent', () => {

package/src/commands/login.ts

@@ -34,6 +34,7 @@ import {
 } from '../opencode.js'
 import { resolveTextChannel, getOttoMetadata } from '../discord-utils.js'
 import { createLogger, LogPrefix } from '../logger.js'
+import { formatOpenCodeResponseError } from '../errors.js'
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js'
 
 const loginLogger = createLogger(LogPrefix.LOGIN)
@@ -266,7 +267,9 @@ export async function handleLoginCommand({
     })
 
     if (!providersResponse.data) {
-      await interaction.editReply({ content: 'Failed to fetch providers' })
+      await interaction.editReply({
+        content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+      })
       return
     }
 
@@ -416,7 +419,10 @@ async function handleProviderStep(
     }
     const providersResponse = await getClient().provider.list({ directory: ctx.dir })
     if (!providersResponse.data) {
-      await interaction.editReply({ content: 'Failed to fetch providers', components: [] })
+      await interaction.editReply({
+        content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+        components: [],
+      })
       return
     }
     const { all: allProviders, connected } = providersResponse.data

package/src/commands/model-variant.ts

@@ -9,7 +9,10 @@
 import {
   ChatInputCommandInteraction,
   StringSelectMenuInteraction,
+  ButtonInteraction,
   StringSelectMenuBuilder,
+  ButtonBuilder,
+  ButtonStyle,
   ActionRowBuilder,
   ChannelType,
   type ThreadChannel,
@@ -34,6 +37,7 @@ import {
 import { getRuntime } from '../session-handler/thread-session-runtime.js'
 import { getThinkingValuesForModel } from '../thinking-utils.js'
 import { createLogger, LogPrefix } from '../logger.js'
+import { formatOpenCodeResponseError } from '../errors.js'
 
 const logger = createLogger(LogPrefix.MODEL)
 
@@ -184,7 +188,9 @@ export async function handleModelVariantCommand({
   }
 
   if (!providersResponse.data) {
-    await interaction.editReply({ content: 'Failed to fetch providers' })
+    await interaction.editReply({
+      content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+    })
     return
   }
 
@@ -424,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({
@@ -474,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({
@@ -483,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,
@@ -30,6 +33,7 @@ import { getDefaultModel } from '../session-handler/model-utils.js'
 import { getRuntime } from '../session-handler/thread-session-runtime.js'
 import { getThinkingValuesForModel } from '../thinking-utils.js'
 import { createLogger, LogPrefix } from '../logger.js'
+import { formatOpenCodeResponseError } from '../errors.js'
 import * as errore from 'errore'
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js'
 
@@ -447,7 +451,7 @@ export async function handleModelCommand({
 
     if (!providersResponse.data) {
       await interaction.editReply({
-        content: 'Failed to fetch providers',
+        content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
       })
       return
     }
@@ -596,7 +600,10 @@ export async function handleProviderSelectMenu(
     }
     const providersResponse = await getClient().provider.list({ directory: context.dir })
     if (!providersResponse.data) {
-      await interaction.editReply({ content: 'Failed to fetch providers', components: [] })
+      await interaction.editReply({
+        content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
+        components: [],
+      })
       return
     }
     const { all: allProviders, connected } = providersResponse.data
@@ -640,7 +647,7 @@ export async function handleProviderSelectMenu(
 
     if (!providersResponse.data) {
       await interaction.editReply({
-        content: 'Failed to fetch providers',
+        content: `Failed to fetch providers: ${formatOpenCodeResponseError(providersResponse.error)}`,
         components: [],
       })
       return
@@ -1016,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)
@@ -1066,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({
@@ -1076,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/discord-bot.ts

@@ -130,11 +130,13 @@ import * as errore from "errore";
 import { createLogger, formatErrorWithStack, LogPrefix } from "./logger.js";
 import { writeHeapSnapshot, startHeapMonitor } from "./heap-monitor.js";
 import { startTaskRunner } from "./task-runner.js";
+import { setGlobalDispatcher, Agent } from "undici";
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
 // Each session's event.subscribe() holds a connection; without enough connections,
 // regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
-// undici is a transitive dep from discord.js — not listed in our package.json.
-// Types are declared in src/undici.d.ts.
+setGlobalDispatcher(
+  new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }),
+);
 
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const voiceLogger = createLogger(LogPrefix.VOICE);

package/src/errors.ts

@@ -168,6 +168,37 @@ export class GitCommandError extends createTaggedError({
   message: 'Git command failed: $command',
 }) {}
 
+export function formatOpenCodeResponseError(error: unknown): string {
+  if (error && typeof error === 'object') {
+    if (
+      'data' in error &&
+      error.data &&
+      typeof error.data === 'object' &&
+      'message' in error.data
+    ) {
+      return String(error.data.message)
+    }
+
+    if (
+      'errors' in error &&
+      Array.isArray(error.errors) &&
+      error.errors.length > 0
+    ) {
+      return JSON.stringify(error.errors)
+    }
+
+    if ('message' in error && typeof error.message === 'string') {
+      return error.message
+    }
+
+    if ('name' in error && typeof error.name === 'string') {
+      return error.name
+    }
+  }
+
+  return 'Unknown OpenCode API error'
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // UNION TYPES - For function signatures
 // ═══════════════════════════════════════════════════════════════════════════

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
         }
 

package/src/opencode.ts

@@ -82,8 +82,10 @@ const ANSI_ESCAPE_REGEX =
 
 async function requestHealthcheck({
   url,
+  timeoutMs = 2000,
 }: {
   url: string
+  timeoutMs?: number
 }): Promise<{ status: number; body: string }> {
   return new Promise((resolve, reject) => {
     const req = http.request(
@@ -107,6 +109,13 @@ async function requestHealthcheck({
         })
       },
     )
+    // Without a timeout, a stalled connection (TCP accepted during opencode
+    // startup before the HTTP layer is ready) hangs forever, wedging
+    // waitForServer on its first iteration and blocking the entire single
+    // server startup promise. Abort and let the poll loop retry instead.
+    req.setTimeout(timeoutMs, () => {
+      req.destroy(new Error(`healthcheck timed out after ${timeoutMs}ms`))
+    })
     req.on('error', reject)
     req.end()
   })