@otto-assistant/otto 0.1.1 → 0.7.15

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

@@ -0,0 +1,751 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+import { ChannelType, MessageFlags } from 'discord.js'
+import fs from 'node:fs'
+
+const mocks = vi.hoisted(() => {
+  return {
+    getChannelDirectory: vi.fn(),
+    setThreadSession: vi.fn(),
+    setPartMessagesBatch: vi.fn(),
+    getAllThreadSessionIds: vi.fn(),
+    getThreadSession: vi.fn(),
+    setChannelModel: vi.fn(),
+    setSessionModel: vi.fn(),
+    setSessionAgent: vi.fn(),
+    getChannelModel: vi.fn(),
+    getSessionModel: vi.fn(),
+    getSessionAgent: vi.fn(),
+    getChannelAgent: vi.fn(),
+    getGlobalModel: vi.fn(),
+    setGlobalModel: vi.fn(),
+    getVariantCascade: vi.fn(),
+    clearSessionModel: vi.fn(),
+    initializeOpencodeForDirectory: vi.fn(),
+    getOpencodeClient: vi.fn(),
+    getDefaultModel: vi.fn(),
+    resolveWorkingDirectory: vi.fn(),
+    resolveProjectDirectoryFromAutocomplete: vi.fn(),
+    sendThreadMessage: vi.fn(),
+    resolveTextChannel: vi.fn(),
+    getOttoMetadata: vi.fn(),
+    getRuntime: vi.fn(),
+    getOrCreateRuntime: vi.fn(),
+    collectSessionChunks: vi.fn(),
+    batchChunksForDiscord: vi.fn(),
+    getThinkingValuesForModel: vi.fn(),
+  }
+})
+
+const mockGetChannelDirectory = mocks.getChannelDirectory
+const mockSetThreadSession = mocks.setThreadSession
+const mockSetPartMessagesBatch = mocks.setPartMessagesBatch
+const mockGetAllThreadSessionIds = mocks.getAllThreadSessionIds
+const mockGetThreadSession = mocks.getThreadSession
+const mockSetChannelModel = mocks.setChannelModel
+const mockSetSessionModel = mocks.setSessionModel
+const mockSetSessionAgent = mocks.setSessionAgent
+const mockGetChannelModel = mocks.getChannelModel
+const mockGetSessionModel = mocks.getSessionModel
+const mockGetSessionAgent = mocks.getSessionAgent
+const mockGetChannelAgent = mocks.getChannelAgent
+const mockGetGlobalModel = mocks.getGlobalModel
+const mockSetGlobalModel = mocks.setGlobalModel
+const mockGetVariantCascade = mocks.getVariantCascade
+const mockClearSessionModel = mocks.clearSessionModel
+const mockInitializeOpencodeForDirectory = mocks.initializeOpencodeForDirectory
+const mockGetOpencodeClient = mocks.getOpencodeClient
+const mockGetDefaultModel = mocks.getDefaultModel
+const mockResolveWorkingDirectory = mocks.resolveWorkingDirectory
+const mockResolveProjectDirectoryFromAutocomplete =
+  mocks.resolveProjectDirectoryFromAutocomplete
+const mockSendThreadMessage = mocks.sendThreadMessage
+const mockResolveTextChannel = mocks.resolveTextChannel
+const mockGetOttoMetadata = mocks.getOttoMetadata
+const mockGetRuntime = mocks.getRuntime
+const mockGetOrCreateRuntime = mocks.getOrCreateRuntime
+const mockCollectSessionChunks = mocks.collectSessionChunks
+const mockBatchChunksForDiscord = mocks.batchChunksForDiscord
+const mockGetThinkingValuesForModel = mocks.getThinkingValuesForModel
+
+vi.mock('../database.js', () => {
+  return {
+    getChannelDirectory: mocks.getChannelDirectory,
+    setThreadSession: mocks.setThreadSession,
+    setPartMessagesBatch: mocks.setPartMessagesBatch,
+    getAllThreadSessionIds: mocks.getAllThreadSessionIds,
+    getThreadSession: mocks.getThreadSession,
+    setChannelModel: mocks.setChannelModel,
+    setSessionModel: mocks.setSessionModel,
+    setSessionAgent: mocks.setSessionAgent,
+    getChannelModel: mocks.getChannelModel,
+    getSessionModel: mocks.getSessionModel,
+    getSessionAgent: mocks.getSessionAgent,
+    getChannelAgent: mocks.getChannelAgent,
+    getGlobalModel: mocks.getGlobalModel,
+    setGlobalModel: mocks.setGlobalModel,
+    getVariantCascade: mocks.getVariantCascade,
+    clearSessionModel: mocks.clearSessionModel,
+  }
+})
+
+vi.mock('../opencode.js', () => {
+  return {
+    initializeOpencodeForDirectory: mocks.initializeOpencodeForDirectory,
+    getOpencodeClient: mocks.getOpencodeClient,
+  }
+})
+
+vi.mock('../session-handler/model-utils.js', () => {
+  return {
+    getDefaultModel: mocks.getDefaultModel,
+  }
+})
+
+vi.mock('../discord-utils.js', () => {
+  return {
+    resolveWorkingDirectory: mocks.resolveWorkingDirectory,
+    resolveProjectDirectoryFromAutocomplete:
+      mocks.resolveProjectDirectoryFromAutocomplete,
+    sendThreadMessage: mocks.sendThreadMessage,
+    resolveTextChannel: mocks.resolveTextChannel,
+    getOttoMetadata: mocks.getOttoMetadata,
+    SILENT_MESSAGE_FLAGS: MessageFlags.SuppressNotifications,
+    NOTIFY_MESSAGE_FLAGS: MessageFlags.SuppressNotifications,
+  }
+})
+
+vi.mock('../session-handler/thread-session-runtime.js', () => {
+  return {
+    getRuntime: mocks.getRuntime,
+    getOrCreateRuntime: mocks.getOrCreateRuntime,
+  }
+})
+
+vi.mock('../message-formatting.js', () => {
+  return {
+    collectSessionChunks: mocks.collectSessionChunks,
+    batchChunksForDiscord: mocks.batchChunksForDiscord,
+  }
+})
+
+vi.mock('../thinking-utils.js', () => {
+  return {
+    getThinkingValuesForModel: mocks.getThinkingValuesForModel,
+  }
+})
+
+vi.mock('../sentry.js', () => {
+  return {
+    notifyError: vi.fn(),
+  }
+})
+
+vi.mock('../store.js', () => {
+  return {
+    store: {
+      getState: vi.fn(() => {
+        return { registeredUserCommands: [] }
+      }),
+    },
+  }
+})
+
+vi.mock('../logger.js', () => {
+  return {
+    LogPrefix: {
+      RESUME: 'resume',
+      SESSION: 'session',
+      ABORT: 'abort',
+      COMPACT: 'compact',
+      MODEL: 'model',
+      AGENT: 'agent',
+      QUEUE: 'queue',
+      UNDO_REDO: 'undo-redo',
+    },
+    createLogger: vi.fn(() => {
+      return {
+        log: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      }
+    }),
+  }
+})
+
+import {
+  handleResumeAutocomplete,
+  handleResumeCommand,
+} from './resume.js'
+import { handleSessionCommand } from './session.js'
+import { handleAbortCommand } from './abort.js'
+import { handleCompactCommand } from './compact.js'
+import { handleModelCommand } from './model.js'
+import { handleAgentCommand } from './agent.js'
+import { handleQueueCommand, handleClearQueueCommand } from './queue.js'
+import { handleUndoCommand, handleRedoCommand } from './undo-redo.js'
+import { handleModelVariantCommand } from './model-variant.js'
+
+type MockOptions = {
+  getString: ReturnType<typeof vi.fn<(name: string, required?: boolean) => string | null>>
+  getInteger: ReturnType<typeof vi.fn<(name: string) => number | null>>
+  getFocused: ReturnType<typeof vi.fn<() => string>>
+  getFocusedTyped: ReturnType<
+    typeof vi.fn<() => { name: string; value: string }>
+  >
+}
+
+function createCommand({
+  channel,
+  userDisplayName = 'SerhiiD',
+}: {
+  channel: unknown
+  userDisplayName?: string
+}) {
+  const options: MockOptions = {
+    getString: vi.fn<(name: string, required?: boolean) => string | null>(),
+    getInteger: vi.fn<(name: string) => number | null>(),
+    getFocused: vi.fn<() => string>(),
+    getFocusedTyped: vi.fn<() => { name: string; value: string }>(),
+  }
+  const command = {
+    channel,
+    user: { id: 'user-1', displayName: userDisplayName },
+    options: {
+      getString: options.getString,
+      getInteger: options.getInteger,
+      getFocused: options.getFocused,
+      getFocusedTyped: options.getFocusedTyped,
+    },
+    deferReply: vi.fn(async (_arg?: unknown) => undefined),
+    editReply: vi.fn(async (_arg?: unknown) => undefined),
+    reply: vi.fn(async (_arg?: unknown) => undefined),
+  }
+  return { command, options }
+}
+
+function createAutocompleteInteraction() {
+  return {
+    options: {
+      getFocused: vi.fn<() => string>(),
+    },
+    respond: vi.fn(async (_arg?: unknown) => undefined),
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mockGetVariantCascade.mockResolvedValue(null)
+  mockGetDefaultModel.mockResolvedValue(undefined)
+  mockGetSessionModel.mockResolvedValue(undefined)
+  mockGetChannelModel.mockResolvedValue(undefined)
+  mockGetGlobalModel.mockResolvedValue(undefined)
+  mockGetSessionAgent.mockResolvedValue(undefined)
+  mockGetChannelAgent.mockResolvedValue(undefined)
+})
+
+describe('/resume', () => {
+  test('resumes selected session in a new thread', async () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+
+    const thread = {
+      id: 'thread-1',
+      members: { add: vi.fn(async () => undefined) },
+      toString: () => '<#thread-1>',
+    }
+    const textChannel = {
+      id: 'channel-1',
+      type: ChannelType.GuildText,
+      threads: {
+        create: vi.fn(async () => thread),
+      },
+    }
+
+    const { command, options } = createCommand({ channel: textChannel })
+    options.getString.mockReturnValue('ses-1')
+
+    mockGetChannelDirectory.mockResolvedValue({ directory: '/repo' })
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {
+        session: {
+          get: vi.fn(async () => {
+            return { data: { title: 'Saved Session', time: { created: 0 } } }
+          }),
+          messages: vi.fn(async () => {
+            return { data: [] }
+          }),
+        },
+      }
+    })
+    mockCollectSessionChunks.mockReturnValue({ chunks: [], skippedCount: 0 })
+    mockBatchChunksForDiscord.mockReturnValue([])
+    mockSendThreadMessage.mockResolvedValue({ id: 'msg-1' })
+
+    await handleResumeCommand({
+      command: command as never,
+      appId: 'app-1',
+    })
+
+    expect(command.editReply).toHaveBeenCalledWith(
+      'Resumed session "Saved Session" in <#thread-1>',
+    )
+    expect(mockSetThreadSession).toHaveBeenCalledWith('thread-1', 'ses-1')
+    const resumeReply = 'Resumed session "Saved Session" in <#thread-1>'
+    expect(resumeReply).toMatchInlineSnapshot(
+      `"Resumed session "Saved Session" in <#thread-1>"`,
+    )
+  })
+
+  test('returns autocomplete options for matching sessions only', async () => {
+    const interaction = createAutocompleteInteraction()
+    interaction.options.getFocused.mockReturnValue('alpha')
+
+    mockResolveProjectDirectoryFromAutocomplete.mockResolvedValue('/repo')
+    mockGetAllThreadSessionIds.mockResolvedValue(['ses-used'])
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {
+        session: {
+          list: vi.fn(async () => {
+            return {
+              data: [
+                {
+                  id: 'ses-1',
+                  title: 'Alpha task',
+                  time: { updated: 0 },
+                },
+                {
+                  id: 'ses-used',
+                  title: 'Alpha existing',
+                  time: { updated: 0 },
+                },
+                {
+                  id: 'ses-2',
+                  title: 'Beta task',
+                  time: { updated: 0 },
+                },
+              ],
+            }
+          }),
+        },
+      }
+    })
+
+    await handleResumeAutocomplete({
+      interaction: interaction as never,
+      appId: 'app-1',
+    })
+
+    const respondCalls = interaction.respond.mock.calls as unknown[][]
+    const firstResponse = respondCalls[0]?.[0]
+    const choices = Array.isArray(firstResponse) ? firstResponse : []
+    const values = choices.map(
+      (choice: { value: string }) => {
+        return choice.value
+      },
+    )
+    expect(values.join(',')).toMatchInlineSnapshot('"ses-1"')
+  })
+})
+
+describe('/new-session', () => {
+  test('creates session thread and enqueues prompt with files', async () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+
+    const thread = {
+      id: 'thread-1',
+      members: { add: vi.fn(async () => undefined) },
+      toString: () => '<#thread-1>',
+    }
+    const starterMessage = {
+      startThread: vi.fn(async () => thread),
+    }
+    const textChannel = {
+      id: 'channel-1',
+      type: ChannelType.GuildText,
+      send: vi.fn(async () => starterMessage),
+    }
+
+    const { command, options } = createCommand({ channel: textChannel })
+    options.getString.mockImplementation((name: string) => {
+      if (name === 'prompt') {
+        return 'Fix typing bug'
+      }
+      if (name === 'files') {
+        return 'src/a.ts, src/b.ts'
+      }
+      return null
+    })
+
+    mockGetChannelDirectory.mockResolvedValue({ directory: '/repo' })
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {}
+    })
+    const enqueueIncoming = vi.fn(async () => undefined)
+    mockGetOrCreateRuntime.mockReturnValue({ enqueueIncoming })
+
+    await handleSessionCommand({
+      command: command as never,
+      appId: 'app-1',
+    })
+
+    expect(command.editReply).toHaveBeenCalledWith(
+      'Created new session in <#thread-1>',
+    )
+    const enqueueCalls = enqueueIncoming.mock.calls as unknown[][]
+    const enqueueInput = (enqueueCalls[0]?.[0] || {}) as { prompt?: string }
+    expect(enqueueInput.prompt || '').toMatchInlineSnapshot(
+      `
+      "Fix typing bug
+
+      @src/a.ts @src/b.ts"
+    `,
+    )
+  })
+})
+
+describe('/abort', () => {
+  test('aborts active runtime in thread', async () => {
+    const thread = { id: 'thread-1', type: ChannelType.PublicThread }
+    const { command } = createCommand({ channel: thread })
+
+    mockResolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo',
+    })
+    mockGetThreadSession.mockResolvedValue('ses-1')
+
+    const abortActiveRun = vi.fn()
+    mockGetRuntime.mockReturnValue({ abortActiveRun })
+
+    await handleAbortCommand({ command: command as never, appId: 'app-1' })
+
+    expect(abortActiveRun).toHaveBeenCalledWith('user-requested')
+    const abortReply = 'Request **aborted**'
+    expect(abortReply).toMatchInlineSnapshot(
+      '"Request **aborted**"',
+    )
+  })
+})
+
+describe('/compact', () => {
+  test('compacts session using last user model', async () => {
+    const thread = { id: 'thread-1', type: ChannelType.PublicThread }
+    const { command } = createCommand({ channel: thread })
+
+    mockResolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo/wt',
+    })
+    mockGetThreadSession.mockResolvedValue('ses-1')
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {}
+    })
+
+    mockGetOpencodeClient.mockReturnValue({
+      session: {
+        messages: vi.fn(async () => {
+          return {
+            data: [
+              {
+                info: {
+                  role: 'user',
+                  model: { providerID: 'openai', modelID: 'gpt-5' },
+                },
+              },
+            ],
+          }
+        }),
+        summarize: vi.fn(async () => {
+          return { data: {} }
+        }),
+      },
+    })
+
+    await handleCompactCommand({ command: command as never, appId: 'app-1' })
+
+    const compactReply = '📦 Session **compacted** successfully'
+    expect(compactReply).toMatchInlineSnapshot(
+      '"📦 Session **compacted** successfully"',
+    )
+  })
+})
+
+describe('/model', () => {
+  test('shows providers and current channel override', async () => {
+    const textChannel = { id: 'channel-1', type: ChannelType.GuildText }
+    const { command } = createCommand({ channel: textChannel })
+
+    mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' })
+    mockGetChannelModel.mockResolvedValue({ modelId: 'openai/gpt-5' })
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {
+        provider: {
+          list: vi.fn(async () => {
+            return {
+              data: {
+                all: [
+                  {
+                    id: 'openai',
+                    name: 'OpenAI',
+                    models: { 'gpt-5': { id: 'gpt-5', name: 'GPT-5' } },
+                  },
+                ],
+                connected: ['openai'],
+              },
+            }
+          }),
+        },
+      }
+    })
+
+    await handleModelCommand({
+      interaction: command as never,
+      appId: 'app-1',
+    })
+
+    const modelHeader =
+      '**Set Model Preference**\n**Current (channel override):** `openai/gpt-5`\nSelect a provider:'
+    expect(modelHeader).toMatchInlineSnapshot(
+      `
+      "**Set Model Preference**
+      **Current (channel override):** \`openai/gpt-5\`
+      Select a provider:"
+    `,
+    )
+  })
+})
+
+describe('/agent', () => {
+  test('shows selectable agents and current channel override', async () => {
+    const textChannel = { id: 'channel-1', type: ChannelType.GuildText }
+    const { command } = createCommand({ channel: textChannel })
+
+    mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' })
+    mockGetChannelAgent.mockResolvedValue('plan')
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {
+        app: {
+          agents: vi.fn(async () => {
+            return {
+              data: [
+                { name: 'plan', mode: 'primary', description: 'Planning' },
+                { name: 'build', mode: 'primary', description: 'Building' },
+              ],
+            }
+          }),
+        },
+      }
+    })
+
+    await handleAgentCommand({
+      interaction: command as never,
+      appId: 'app-1',
+    })
+
+    const agentHeader =
+      '**Set Agent Preference**\n**Current (channel override):** `plan`\nSelect an agent:'
+    expect(agentHeader).toMatchInlineSnapshot(
+      `
+      "**Set Agent Preference**
+      **Current (channel override):** \`plan\`
+      Select an agent:"
+    `,
+    )
+  })
+})
+
+describe('/queue and /clear-queue', () => {
+  test('/queue enqueues message and confirms queue position', async () => {
+    const thread = {
+      id: 'thread-1',
+      parentId: 'channel-1',
+      type: ChannelType.PublicThread,
+    }
+    const { command, options } = createCommand({ channel: thread })
+    options.getString.mockReturnValue('Run tests after this')
+
+    mockGetThreadSession.mockResolvedValue('ses-1')
+    mockResolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo',
+    })
+    mockGetOrCreateRuntime.mockReturnValue({
+      enqueueIncoming: vi.fn(async () => {
+        return { queued: true, position: 2 }
+      }),
+    })
+
+    await handleQueueCommand({ command: command as never, appId: 'app-1' })
+
+    const queueReply = 'Queued message (position 2)'
+    expect(queueReply).toMatchInlineSnapshot(
+      '"Queued message (position 2)"',
+    )
+  })
+
+  test('/clear-queue removes specific position', async () => {
+    const thread = { id: 'thread-1', type: ChannelType.PublicThread }
+    const { command, options } = createCommand({ channel: thread })
+    options.getInteger.mockReturnValue(2)
+
+    mockGetRuntime.mockReturnValue({
+      getQueueLength: () => 3,
+      removeQueuePosition: () => true,
+    })
+
+    await handleClearQueueCommand({ command: command as never, appId: 'app-1' })
+
+    const clearQueueReply = 'Cleared queued message at position 2'
+    expect(clearQueueReply).toMatchInlineSnapshot(
+      '"Cleared queued message at position 2"',
+    )
+  })
+})
+
+describe('/undo and /redo', () => {
+  test('/undo reverts to previous assistant message', async () => {
+    const thread = { id: 'thread-1', type: ChannelType.PublicThread }
+    const { command } = createCommand({ channel: thread })
+
+    mockResolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo',
+    })
+    mockGetThreadSession.mockResolvedValue('ses-1')
+
+    const client = {
+      session: {
+        get: vi.fn(async () => {
+          return { data: { revert: undefined } }
+        }),
+        status: vi.fn(async () => {
+          return { data: {} }
+        }),
+        messages: vi.fn(async () => {
+          return {
+            data: [
+              { info: { id: 'u1', role: 'user' } },
+              { info: { id: 'a1', role: 'assistant', parentID: 'u1' } },
+            ],
+          }
+        }),
+        revert: vi.fn(async () => {
+          return { data: { revert: { diff: '' } } }
+        }),
+      },
+    }
+
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => client)
+
+    await handleUndoCommand({ command: command as never, appId: 'app-1' })
+
+    const undoReply = 'Undone - reverted last assistant message'
+    expect(undoReply).toMatchInlineSnapshot(
+      '"Undone - reverted last assistant message"',
+    )
+  })
+
+  test('/redo reports when nothing can be redone', async () => {
+    const thread = { id: 'thread-1', type: ChannelType.PublicThread }
+    const { command } = createCommand({ channel: thread })
+
+    mockResolveWorkingDirectory.mockResolvedValue({
+      projectDirectory: '/repo',
+      workingDirectory: '/repo',
+    })
+    mockGetThreadSession.mockResolvedValue('ses-1')
+
+    const client = {
+      session: {
+        get: vi.fn(async () => {
+          return { data: { revert: undefined } }
+        }),
+      },
+    }
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => client)
+
+    await handleRedoCommand({ command: command as never, appId: 'app-1' })
+
+    const redoReply = 'Nothing to redo - no previous undo found'
+    expect(redoReply).toMatchInlineSnapshot(
+      '"Nothing to redo - no previous undo found"',
+    )
+  })
+})
+
+describe('/model-variant', () => {
+  test('returns message when no model is configured', 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 { data: { all: [], connected: [] } }
+          }),
+        },
+      }
+    })
+
+    await handleModelVariantCommand({
+      interaction: command as never,
+      appId: 'app-1',
+    })
+
+    const noModelReply = 'No model configured. Use `/model` to set one first.'
+    expect(noModelReply).toMatchInlineSnapshot(
+      '"No model configured. Use `/model` to set one first."',
+    )
+  })
+
+  test('shows variant and scope menus for current model', async () => {
+    const textChannel = { id: 'channel-1', type: ChannelType.GuildText }
+    const { command } = createCommand({ channel: textChannel })
+
+    mockGetOttoMetadata.mockResolvedValue({ projectDirectory: '/repo' })
+    mockGetChannelModel.mockResolvedValue({ modelId: 'openai/gpt-5' })
+    mockGetVariantCascade.mockResolvedValue('high')
+    mockGetThinkingValuesForModel.mockReturnValue(['low', 'high'])
+    mockInitializeOpencodeForDirectory.mockResolvedValue(() => {
+      return {
+        provider: {
+          list: vi.fn(async () => {
+            return {
+              data: {
+                all: [
+                  {
+                    id: 'openai',
+                    name: 'OpenAI',
+                    models: {
+                      'gpt-5': {
+                        id: 'gpt-5',
+                        name: 'GPT-5',
+                        release_date: '2026-01-01',
+                      },
+                    },
+                  },
+                ],
+                connected: ['openai'],
+              },
+            }
+          }),
+        },
+      }
+    })
+
+    await handleModelVariantCommand({
+      interaction: command as never,
+      appId: 'app-1',
+    })
+
+    const variantHeader =
+      '**Current model:** `openai/gpt-5` (high) — channel override\nSelect a thinking level and where to apply it:'
+    expect(variantHeader).toMatchInlineSnapshot(
+      `
+      "**Current model:** \`openai/gpt-5\` (high) — channel override
+      Select a thinking level and where to apply it:"
+    `,
+    )
+  })
+})