kimaki 0.31.0 → 1.0.0

package/src/commands/agent.ts

@@ -1,911 +0,0 @@
-// /agent command - Set the preferred agent for this channel or session.
-// Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
-// When a prompt is provided to a quick agent command (e.g. /plan-agent "fix the bug"),
-// the prompt is sent with that agent and the session keeps that agent afterwards.
-// Optional last `variant` option sets the model thinking level for that agent.
-
-import {
-  ChatInputCommandInteraction,
-  StringSelectMenuInteraction,
-  StringSelectMenuBuilder,
-  ActionRowBuilder,
-  ChannelType,
-  ThreadAutoArchiveDuration,
-  type ThreadChannel,
-  type TextChannel,
-  MessageFlags,
-} from 'discord.js'
-import crypto from 'node:crypto'
-import {
-  setChannelAgent,
-  setSessionAgent,
-  setSessionModel,
-  setChannelModel,
-  getChannelModel,
-  clearSessionModel,
-  getThreadSession,
-  getSessionAgent,
-  getChannelAgent,
-  getChannelWorktreesEnabled,
-} from '../database.js'
-import { initializeOpencodeForDirectory } from '../opencode.js'
-import {
-  resolveTextChannel,
-  resolveWorkingDirectory,
-  resolveProjectDirectoryFromAutocomplete,
-  getKimakiMetadata,
-  SILENT_MESSAGE_FLAGS,
-} from '../discord-utils.js'
-import {
-  getOrCreateRuntime,
-  releaseCurrentThreadIngress,
-  waitForCurrentThreadIngress,
-} from '../session-handler/thread-session-runtime.js'
-import { createLogger, LogPrefix } from '../logger.js'
-import {
-  formatModelSource,
-  getCurrentModelInfo,
-  type CurrentModelInfo,
-} from './model.js'
-import { isGitRepositoryRoot } from '../worktrees.js'
-import {
-  formatAutoWorktreeName,
-  createWorktreeInBackground,
-  worktreeCreatingMessage,
-} from './new-worktree.js'
-import { WORKTREE_PREFIX } from './merge-worktree.js'
-import { QUEUE_PREFIX } from '../message-formatting.js'
-import { store } from '../store.js'
-import {
-  getThinkingValuesForModel,
-  resolveRequestedThinkingVariant,
-} from '../thinking-utils.js'
-import type { AutocompleteContext } from './types.js'
-import { OpenCodeSdkError } from '../errors.js'
-
-const agentLogger = createLogger(LogPrefix.AGENT)
-
-const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000
-const pendingAgentContexts = new Map<string, AgentCommandContext>()
-
-/**
- * Context for agent commands, containing channel/session info.
- */
-export type AgentCommandContext = {
-  dir: string
-  workingDirectory: string
-  channelId: string
-  sessionId?: string
-  isThread: boolean
-  appId: string
-}
-
-export type CurrentAgentInfo =
-  | { type: 'session'; agent: string }
-  | { type: 'channel'; agent: string }
-  | { type: 'none' }
-
-/**
- * Get the current agent info for a channel/session, including where it comes from.
- * Priority: session > channel > none
- */
-export async function getCurrentAgentInfo({
-  sessionId,
-  channelId,
-}: {
-  sessionId?: string
-  channelId?: string
-}): Promise<CurrentAgentInfo> {
-  if (sessionId) {
-    const sessionAgent = await getSessionAgent(sessionId)
-    if (sessionAgent) {
-      return { type: 'session', agent: sessionAgent }
-    }
-  }
-  if (channelId) {
-    const channelAgent = await getChannelAgent(channelId)
-    if (channelAgent) {
-      return { type: 'channel', agent: channelAgent }
-    }
-  }
-  return { type: 'none' }
-}
-
-/**
- * Sanitize an agent name to be a valid Discord command name component.
- * Lowercase, alphanumeric and hyphens only.
- */
-export function sanitizeAgentName(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-}
-
-const QUICK_AGENT_DESCRIPTION_PATTERN = /^\[agent:([^\]]+)\]/
-
-/**
- * Build quick-agent command description with an embedded original agent name.
- * Metadata format: [agent:<original-name>] <visible description>
- */
-export function buildQuickAgentCommandDescription({
-  agentName,
-  description,
-}: {
-  agentName: string
-  description?: string
-}): string {
-  const metadataPrefix = `[agent:${agentName}]`
-  if (metadataPrefix.length > 100) {
-    return metadataPrefix.slice(0, 100)
-  }
-
-  const visibleDescription = description || `Switch to ${agentName} agent`
-  const maxVisibleLength = 100 - metadataPrefix.length - 1
-
-  if (maxVisibleLength <= 0) {
-    return metadataPrefix
-  }
-
-  const trimmedVisible = visibleDescription.slice(0, maxVisibleLength).trim()
-  if (!trimmedVisible) {
-    return metadataPrefix
-  }
-
-  return `${metadataPrefix} ${trimmedVisible}`
-}
-
-function parseQuickAgentNameFromDescription(
-  description: string | undefined,
-): string | undefined {
-  if (!description) {
-    return undefined
-  }
-  const match = QUICK_AGENT_DESCRIPTION_PATTERN.exec(description)
-  if (!match) {
-    return undefined
-  }
-  const agentName = match[1]?.trim()
-  if (!agentName) {
-    return undefined
-  }
-  return agentName
-}
-
-async function resolveQuickAgentNameFromInteraction({
-  command,
-}: {
-  command: ChatInputCommandInteraction
-}): Promise<string | undefined> {
-  const fromCommandObject = parseQuickAgentNameFromDescription(
-    command.command?.description,
-  )
-  if (fromCommandObject) {
-    return fromCommandObject
-  }
-
-  if (!command.guild) {
-    return undefined
-  }
-
-  const fetchedCommand = await command.guild.commands.fetch(command.commandId)
-  if (!fetchedCommand) {
-    return undefined
-  }
-
-  return parseQuickAgentNameFromDescription(fetchedCommand.description)
-}
-
-/**
- * Resolve the context for an agent command (directory, channel, session).
- * Returns null if the command cannot be executed in this context.
- */
-export async function resolveAgentCommandContext({
-  interaction,
-  appId,
-}: {
-  interaction: ChatInputCommandInteraction
-  appId: string
-}): Promise<AgentCommandContext | null> {
-  const channel = interaction.channel
-
-  if (!channel) {
-    await interaction.editReply({
-      content: 'This command can only be used in a channel',
-    })
-    return null
-  }
-
-  const isThread = [
-    ChannelType.PublicThread,
-    ChannelType.PrivateThread,
-    ChannelType.AnnouncementThread,
-  ].includes(channel.type)
-
-  if (
-    !isThread &&
-    channel.type !== ChannelType.GuildText
-  ) {
-    await interaction.editReply({
-      content: 'This command can only be used in text channels or threads',
-    })
-    return null
-  }
-
-  const resolved = await resolveWorkingDirectory({
-    channel: channel as TextChannel | ThreadChannel,
-  })
-  if (!resolved) {
-    await interaction.editReply({
-      content: 'This channel is not configured with a project directory',
-    })
-    return null
-  }
-
-  const textChannel = isThread
-    ? await resolveTextChannel(channel as ThreadChannel)
-    : undefined
-  const sessionId = isThread
-    ? await getThreadSession(channel.id)
-    : undefined
-
-  return {
-    dir: resolved.projectDirectory,
-    workingDirectory: resolved.workingDirectory,
-    channelId: textChannel?.id || channel.id,
-    sessionId,
-    isThread,
-    appId,
-  }
-}
-
-/**
- * Set the agent preference for a context (session or channel).
- * When switching agents for a session, clears session model preference
- * so the new agent's model takes effect (agent model > channel model).
- */
-export async function setAgentForContext({
-  context,
-  agentName,
-}: {
-  context: AgentCommandContext
-  agentName: string
-}): Promise<void> {
-  if (context.isThread && context.sessionId) {
-    await setSessionAgent(context.sessionId, agentName)
-    // Clear session model so the new agent's model takes effect
-    await clearSessionModel(context.sessionId)
-    agentLogger.log(
-      `Set agent ${agentName} for session ${context.sessionId} (cleared session model)`,
-    )
-  } else {
-    await setChannelAgent(context.channelId, agentName)
-    agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`)
-  }
-}
-
-async function applyQuickAgentVariant({
-  context,
-  agentName,
-  variant,
-}: {
-  context: AgentCommandContext
-  agentName: string
-  variant: string
-}): Promise<string | undefined> {
-  const modelInfo = await resolveAgentModelInfo({ context, agentName })
-  if (modelInfo.type === 'none') {
-    agentLogger.warn(
-      `[AGENT] Skipping variant ${variant}: no model for agent ${agentName}`,
-    )
-    return undefined
-  }
-
-  const getClient = await initializeOpencodeForDirectory(context.dir)
-  if (getClient instanceof Error) return undefined
-
-  const providersResponse = await getClient()
-    .provider.list({ directory: context.workingDirectory })
-    .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e }))
-  if (providersResponse instanceof Error || !providersResponse.data) {
-    agentLogger.warn(`[AGENT] Skipping variant ${variant}: provider list failed`)
-    return undefined
-  }
-
-  const matchedVariant = resolveRequestedThinkingVariant({
-    requestedValue: variant,
-    providers: providersResponse.data.all,
-    providerId: modelInfo.providerID,
-    modelId: modelInfo.modelID,
-  })
-  if (!matchedVariant) {
-    agentLogger.warn(
-      `[AGENT] Skipping variant ${variant}: not supported by ${modelInfo.model}`,
-    )
-    return undefined
-  }
-
-  if (context.isThread && context.sessionId) {
-    await setSessionModel({
-      sessionId: context.sessionId,
-      modelId: modelInfo.model,
-      variant: matchedVariant,
-    })
-    return matchedVariant
-  }
-
-  const existing = await getChannelModel(context.channelId)
-  await setChannelModel({
-    channelId: context.channelId,
-    modelId: existing?.modelId ?? modelInfo.model,
-    variant: matchedVariant,
-  })
-  return matchedVariant
-}
-
-function formatAgentModelLine(modelInfo: CurrentModelInfo): string {
-  if (modelInfo.type === 'none') return ''
-  const source = formatModelSource({
-    type: modelInfo.type,
-    agentName: modelInfo.type === 'agent' ? modelInfo.agentName : undefined,
-  })
-  const line = `\nModel: *${modelInfo.model}* (${source})`
-  if (modelInfo.type !== 'session' && modelInfo.type !== 'channel') {
-    return line
-  }
-  return `${line}\nThis model comes from a ${modelInfo.type} override. Use /model and press Clear override if you want this agent's model.`
-}
-
-function formatAgentPreferenceReply({
-  agentName,
-  previousAgentName,
-  modelInfo,
-  scope,
-  variant,
-}: {
-  agentName: string
-  previousAgentName?: string
-  modelInfo: CurrentModelInfo
-  scope: 'session' | 'channel'
-  variant?: string
-}): string {
-  const sameAgent = previousAgentName === agentName
-  const verb = sameAgent ? 'Using' : 'Switched to'
-  const previousText =
-    !sameAgent && previousAgentName ? ` (was **${previousAgentName}**)` : ''
-  const modelText = formatAgentModelLine(modelInfo)
-  const variantText = variant ? `\nVariant: **${variant}**` : ''
-  if (scope === 'session') {
-    return `${verb} **${agentName}** agent for this session${previousText}${modelText}${variantText}\nThe agent will change on the next message.`
-  }
-  return `${verb} **${agentName}** agent for this channel${previousText}${modelText}${variantText}\nAll new sessions will use this agent.`
-}
-
-async function resolveAgentModelInfo({
-  context,
-  agentName,
-}: {
-  context: AgentCommandContext
-  agentName: string
-}): Promise<CurrentModelInfo> {
-  const getClient = await initializeOpencodeForDirectory(context.dir)
-  if (getClient instanceof Error) return { type: 'none' }
-  return getCurrentModelInfo({
-    sessionId: context.sessionId,
-    channelId: context.channelId,
-    appId: context.appId,
-    agentPreference: agentName,
-    getClient,
-    directory: context.workingDirectory,
-  })
-}
-
-export async function handleAgentCommand({
-  interaction,
-  appId,
-}: {
-  interaction: ChatInputCommandInteraction
-  appId: string
-}): Promise<void> {
-  await interaction.deferReply()
-
-  const context = await resolveAgentCommandContext({ interaction, appId })
-  if (!context) {
-    return
-  }
-
-  try {
-    const getClient = await initializeOpencodeForDirectory(context.dir)
-    if (getClient instanceof Error) {
-      await interaction.editReply({ content: getClient.message })
-      return
-    }
-
-    const agentsResponse = await getClient().app.agents({
-      directory: context.workingDirectory,
-    })
-
-    if (!agentsResponse.data || agentsResponse.data.length === 0) {
-      await interaction.editReply({ content: 'No agents available' })
-      return
-    }
-
-    const agents = agentsResponse.data
-      .filter((agent) => {
-        const hidden = (agent as { hidden?: boolean }).hidden
-        return (agent.mode === 'primary' || agent.mode === 'all') && !hidden
-      })
-      .slice(0, 25)
-
-    if (agents.length === 0) {
-      await interaction.editReply({ content: 'No primary agents available' })
-      return
-    }
-
-    const currentAgentInfo = await getCurrentAgentInfo({
-      sessionId: context.sessionId,
-      channelId: context.channelId,
-    })
-
-    const currentAgentText = (() => {
-      switch (currentAgentInfo.type) {
-        case 'session':
-          return `**Current (session override):** \`${currentAgentInfo.agent}\``
-        case 'channel':
-          return `**Current (channel override):** \`${currentAgentInfo.agent}\``
-        case 'none':
-          return '**Current:** none'
-      }
-    })()
-
-    const contextHash = crypto.randomBytes(8).toString('hex')
-    pendingAgentContexts.set(contextHash, context)
-    setTimeout(() => {
-      pendingAgentContexts.delete(contextHash)
-    }, AGENT_CONTEXT_TTL_MS).unref()
-
-    const options = agents.map((agent) => ({
-      label: agent.name.slice(0, 100),
-      value: agent.name,
-      description: (agent.description || `${agent.mode} agent`).slice(0, 100),
-    }))
-
-    const selectMenu = new StringSelectMenuBuilder()
-      .setCustomId(`agent_select:${contextHash}`)
-      .setPlaceholder('Select an agent')
-      .addOptions(options)
-
-    const actionRow =
-      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
-
-    await interaction.editReply({
-      content: `**Set Agent Preference**\n${currentAgentText}\nSelect an agent:`,
-      components: [actionRow],
-    })
-  } catch (error) {
-    agentLogger.error('Error loading agents:', error)
-    await interaction.editReply({
-      content: `Failed to load agents: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    })
-  }
-}
-
-export async function handleAgentSelectMenu(
-  interaction: StringSelectMenuInteraction,
-): Promise<void> {
-  const customId = interaction.customId
-
-  if (!customId.startsWith('agent_select:')) {
-    return
-  }
-
-  await interaction.deferUpdate()
-
-  const contextHash = customId.replace('agent_select:', '')
-  const context = pendingAgentContexts.get(contextHash)
-
-  if (!context) {
-    await interaction.editReply({
-      content: 'Selection expired. Please run /agent again.',
-      components: [],
-    })
-    return
-  }
-
-  const selectedAgent = interaction.values[0]
-  if (!selectedAgent) {
-    await interaction.editReply({
-      content: 'No agent selected',
-      components: [],
-    })
-    return
-  }
-
-  try {
-    const previousAgent = await getCurrentAgentInfo({
-      sessionId: context.sessionId,
-      channelId: context.channelId,
-    })
-    const previousAgentName =
-      previousAgent.type !== 'none' ? previousAgent.agent : undefined
-
-    await waitForCurrentThreadIngress()
-    try {
-      await setAgentForContext({ context, agentName: selectedAgent })
-    } finally {
-      releaseCurrentThreadIngress()
-    }
-    const modelInfo = await resolveAgentModelInfo({
-      context,
-      agentName: selectedAgent,
-    })
-    const scope =
-      context.isThread && context.sessionId ? 'session' : 'channel'
-
-    await interaction.editReply({
-      content: formatAgentPreferenceReply({
-        agentName: selectedAgent,
-        previousAgentName,
-        modelInfo,
-        scope,
-      }),
-      components: [],
-    })
-
-    pendingAgentContexts.delete(contextHash)
-  } catch (error) {
-    agentLogger.error('Error saving agent preference:', error)
-    await interaction.editReply({
-      content: `Failed to save agent preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      components: [],
-    })
-  }
-}
-
-/**
- * Handle quick agent commands like /plan-agent, /build-agent.
- * These instantly switch to the specified agent without showing a dropdown.
- *
- * The slash command name is sanitized for Discord and can be lossy
- * (for example gpt5.4 -> gpt5-4-agent). To keep the original agent name,
- * registration stores [agent:<name>] metadata in the description and this
- * handler resolves from that metadata first.
- */
-export async function handleQuickAgentCommand({
-  command,
-  appId,
-}: {
-  command: ChatInputCommandInteraction
-  appId: string
-}): Promise<void> {
-  const fallbackAgentName = command.commandName.replace(/-agent$/, '')
-  const prompt = command.options.getString('prompt') || undefined
-  const variant = command.options.getString('variant') || undefined
-
-  // Prompt mode: send the prompt with this agent immediately.
-  if (prompt) {
-    return handleQuickAgentWithPrompt({
-      command,
-      appId,
-      fallbackAgentName,
-      prompt,
-      variant,
-    })
-  }
-
-  // No prompt: switch the persistent agent preference (original behavior).
-  await command.deferReply()
-
-  const context = await resolveAgentCommandContext({
-    interaction: command,
-    appId,
-  })
-  if (!context) {
-    return
-  }
-
-  try {
-    const resolvedAgentName =
-      (await resolveQuickAgentNameFromInteraction({ command })) ||
-      fallbackAgentName
-
-    // Check current agent and set new one.
-    // getCurrentAgentInfo is fast (DB only), use it for the "was X" text.
-    const previousAgent = await getCurrentAgentInfo({
-      sessionId: context.sessionId,
-      channelId: context.channelId,
-    })
-    const previousAgentName =
-      previousAgent.type !== 'none' ? previousAgent.agent : undefined
-
-    await waitForCurrentThreadIngress()
-    try {
-      await setAgentForContext({ context, agentName: resolvedAgentName })
-      const modelInfo = await resolveAgentModelInfo({
-        context,
-        agentName: resolvedAgentName,
-      })
-      const appliedVariant = variant
-        ? await applyQuickAgentVariant({
-            context,
-            agentName: resolvedAgentName,
-            variant,
-          })
-        : undefined
-      const scope =
-        context.isThread && context.sessionId ? 'session' : 'channel'
-      const unsupportedVariantNote =
-        variant && !appliedVariant
-          ? `\nVariant **${variant}** is not supported by this agent's model.`
-          : ''
-
-      await command.editReply({
-        content: `${formatAgentPreferenceReply({
-          agentName: resolvedAgentName,
-          previousAgentName,
-          modelInfo,
-          scope,
-          variant: appliedVariant,
-        })}${unsupportedVariantNote}`,
-      })
-    } finally {
-      releaseCurrentThreadIngress()
-    }
-  } catch (error) {
-    agentLogger.error('Error in quick agent command:', error)
-    await command.editReply({
-      content: `Failed to switch agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    })
-  }
-}
-
-/**
- * Handle prompt mode: send a prompt with the requested agent.
- * In a thread: enqueue the prompt on the existing session and switch that session.
- * In a channel: create a new thread whose session starts with the requested agent.
- * Channel-level preferences are not changed.
- */
-async function handleQuickAgentWithPrompt({
-  command,
-  appId,
-  fallbackAgentName,
-  prompt,
-  variant,
-}: {
-  command: ChatInputCommandInteraction
-  appId: string
-  fallbackAgentName: string
-  prompt: string
-  variant?: string
-}): Promise<void> {
-  const channel = command.channel
-  if (!channel) {
-    await command.reply({
-      content: 'This command can only be used in a channel',
-      flags: MessageFlags.Ephemeral,
-    })
-    return
-  }
-
-  const resolvedAgentName =
-    (await resolveQuickAgentNameFromInteraction({ command })) ||
-    fallbackAgentName
-
-  const isThread = [
-    ChannelType.PublicThread,
-    ChannelType.PrivateThread,
-    ChannelType.AnnouncementThread,
-  ].includes(channel.type)
-
-  const displayText = `${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`
-
-  if (isThread) {
-    // In a thread: enqueue the prompt and switch the existing session to this agent.
-    const thread = channel as ThreadChannel
-    const resolved = await resolveWorkingDirectory({ channel: thread })
-    if (!resolved) {
-      await command.reply({
-        content: 'Could not determine project directory for this channel',
-        flags: MessageFlags.Ephemeral,
-      })
-      return
-    }
-
-    const runtime = getOrCreateRuntime({
-      threadId: thread.id,
-      thread,
-      projectDirectory: resolved.projectDirectory,
-      sdkDirectory: resolved.workingDirectory,
-      channelId: thread.parentId || thread.id,
-      appId,
-    })
-
-    // Visible reply showing the one-shot prompt (not ephemeral, so it appears in thread).
-    await command.reply({
-      content: `${QUEUE_PREFIX}**${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
-      flags: SILENT_MESSAGE_FLAGS,
-    })
-
-    await runtime.enqueueIncoming({
-      prompt,
-      userId: command.user.id,
-      username: command.user.displayName,
-      agent: resolvedAgentName,
-      appId,
-      mode: 'opencode',
-      variant,
-    })
-  } else if (channel.type === ChannelType.GuildText) {
-    // In a channel: create a new thread and enqueue with the requested agent.
-    const metadata = await getKimakiMetadata(channel)
-    const projectDirectory = metadata.projectDirectory
-
-    if (!projectDirectory) {
-      await command.reply({
-        content: 'This channel is not configured with a project directory',
-        flags: MessageFlags.Ephemeral,
-      })
-      return
-    }
-
-    await command.deferReply()
-
-    // Check if worktrees should be enabled (CLI flag OR channel setting),
-    // mirroring the logic in discord-bot.ts message handler.
-    const wantsWorktrees =
-      store.getState().useWorktrees ||
-      (await getChannelWorktreesEnabled(channel.id))
-    const shouldUseWorktrees =
-      wantsWorktrees && (await isGitRepositoryRoot(projectDirectory))
-
-    if (wantsWorktrees && !shouldUseWorktrees) {
-      agentLogger.warn(
-        `[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`,
-      )
-    }
-
-    const baseThreadName = prompt.slice(0, 80)
-    const threadName = shouldUseWorktrees
-      ? `${WORKTREE_PREFIX}${baseThreadName}`
-      : baseThreadName
-
-    const starterMessage = await channel.send({
-      content: `${QUEUE_PREFIX}**${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
-      flags: SILENT_MESSAGE_FLAGS,
-    })
-
-    const thread = await starterMessage.startThread({
-      name: threadName.slice(0, 80),
-      autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
-      reason: `${resolvedAgentName} agent prompt`,
-    })
-
-    await thread.members.add(command.user.id)
-
-    // Create worktree in background if enabled, same as discord-bot.ts
-    let worktreePromise: Promise<string | Error> | undefined
-    if (shouldUseWorktrees) {
-      const worktreeName = formatAutoWorktreeName(baseThreadName.slice(0, 50))
-      agentLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`)
-
-      const worktreeStatusMessage = await thread
-        .send({
-          content: worktreeCreatingMessage(worktreeName),
-          flags: SILENT_MESSAGE_FLAGS,
-        })
-        .catch(() => undefined)
-
-      worktreePromise = createWorktreeInBackground({
-        thread,
-        starterMessage: worktreeStatusMessage,
-        worktreeName,
-        projectDirectory,
-        rest: command.client.rest,
-      })
-    }
-
-    const worktreeResult = worktreePromise ? await worktreePromise : projectDirectory
-    if (worktreeResult instanceof Error) {
-      await command.editReply(`Worktree creation failed: ${worktreeResult.message}`)
-      return
-    }
-    const sessionDirectory = worktreeResult
-
-    await command
-      .editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
-      .catch(() => {
-        agentLogger.warn('[AGENT] Failed to edit quick-agent reply, continuing session')
-      })
-
-    const runtime = getOrCreateRuntime({
-      threadId: thread.id,
-      thread,
-      projectDirectory,
-      sdkDirectory: sessionDirectory,
-      channelId: channel.id,
-      appId,
-    })
-
-    await runtime.enqueueIncoming({
-      prompt,
-      userId: command.user.id,
-      username: command.user.displayName,
-      agent: resolvedAgentName,
-      appId,
-      mode: 'opencode',
-      variant,
-    })
-  } else {
-    await command.reply({
-      content: 'This command can only be used in text channels or threads',
-      flags: MessageFlags.Ephemeral,
-    })
-  }
-}
-
-export async function handleQuickAgentAutocomplete({
-  interaction,
-}: AutocompleteContext): Promise<void> {
-  if (interaction.options.getFocused(true).name !== 'variant') {
-    await interaction.respond([])
-    return
-  }
-
-  const focusedValue = interaction.options.getFocused().trim().toLowerCase()
-  const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction)
-  if (!projectDirectory) {
-    await interaction.respond([])
-    return
-  }
-
-  const getClient = await initializeOpencodeForDirectory(projectDirectory)
-  if (getClient instanceof Error) {
-    await interaction.respond([])
-    return
-  }
-
-  const [providersResponse, agentsResponse] = await Promise.all([
-    getClient()
-      .provider.list({ directory: projectDirectory })
-      .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e })),
-    getClient()
-      .app.agents({ directory: projectDirectory })
-      .catch((e) => new OpenCodeSdkError({ operation: 'app.agents', cause: e })),
-  ])
-  if (providersResponse instanceof Error || agentsResponse instanceof Error) {
-    agentLogger.warn('[AUTOCOMPLETE] Failed to fetch variant choices')
-    await interaction.respond([])
-    return
-  }
-  if (!providersResponse.data || !agentsResponse.data) {
-    await interaction.respond([])
-    return
-  }
-
-  const resolvedAgentName =
-    parseQuickAgentNameFromDescription(interaction.command?.description) ||
-    interaction.commandName.replace(/-agent$/, '')
-  const agent = agentsResponse.data.find((candidate) => candidate.name === resolvedAgentName)
-  const agentModel = agent?.model
-  if (!agentModel) {
-    await interaction.respond([])
-    return
-  }
-
-  const variants = getThinkingValuesForModel({
-    providers: providersResponse.data.all,
-    providerId: agentModel.providerID,
-    modelId: agentModel.modelID,
-  }).filter((variant) => {
-    if (!focusedValue) return true
-    return variant.toLowerCase().includes(focusedValue)
-  })
-
-  await interaction.respond(
-    variants.slice(0, 25).map((variant) => ({
-      name: variant.slice(0, 100),
-      value: variant,
-    })),
-  )
-}