kimaki 0.26.0 → 0.28.0

package/src/commands/add-project.ts

@@ -4,7 +4,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import type { CommandContext, AutocompleteContext } from './types.js'
 import {
-  findChannelsByDirectory,
+  findRegisteredTextChannelForDirectory,
   getAllTextChannelDirectories,
 } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
@@ -56,14 +56,10 @@ export async function handleAddProjectCommand({
       return
     }
 
-    const existingChannels = await findChannelsByDirectory({
-      directory,
-      channelType: 'text',
-    })
-
-    if (existingChannels.length > 0) {
+    const existingChannel = await findRegisteredTextChannelForDirectory(directory)
+    if (existingChannel) {
       await command.editReply(
-        `A channel already exists for this directory: <#${existingChannels[0]!.channel_id}>`,
+        `A channel already exists for this directory: <#${existingChannel.channel_id}>`,
       )
       return
     }

package/src/commands/agent.ts

@@ -2,6 +2,7 @@
 // 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,
@@ -18,6 +19,9 @@ import crypto from 'node:crypto'
 import {
   setChannelAgent,
   setSessionAgent,
+  setSessionModel,
+  setChannelModel,
+  getChannelModel,
   clearSessionModel,
   getThreadSession,
   getSessionAgent,
@@ -28,10 +32,15 @@ import { initializeOpencodeForDirectory } from '../opencode.js'
 import {
   resolveTextChannel,
   resolveWorkingDirectory,
+  resolveProjectDirectoryFromAutocomplete,
   getKimakiMetadata,
   SILENT_MESSAGE_FLAGS,
 } from '../discord-utils.js'
-import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js'
+import {
+  getOrCreateRuntime,
+  releaseCurrentThreadIngress,
+  waitForCurrentThreadIngress,
+} from '../session-handler/thread-session-runtime.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import {
   formatModelSource,
@@ -45,7 +54,14 @@ import {
   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)
 
@@ -269,6 +285,65 @@ export async function setAgentForContext({
   }
 }
 
+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({
@@ -287,21 +362,24 @@ function formatAgentPreferenceReply({
   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}\nThe agent will change on the next message.`
+    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}\nAll new sessions will use this agent.`
+  return `${verb} **${agentName}** agent for this channel${previousText}${modelText}${variantText}\nAll new sessions will use this agent.`
 }
 
 async function resolveAgentModelInfo({
@@ -452,7 +530,12 @@ export async function handleAgentSelectMenu(
     const previousAgentName =
       previousAgent.type !== 'none' ? previousAgent.agent : undefined
 
-    await setAgentForContext({ context, agentName: selectedAgent })
+    await waitForCurrentThreadIngress()
+    try {
+      await setAgentForContext({ context, agentName: selectedAgent })
+    } finally {
+      releaseCurrentThreadIngress()
+    }
     const modelInfo = await resolveAgentModelInfo({
       context,
       agentName: selectedAgent,
@@ -498,10 +581,17 @@ export async function handleQuickAgentCommand({
 }): 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 })
+    return handleQuickAgentWithPrompt({
+      command,
+      appId,
+      fallbackAgentName,
+      prompt,
+      variant,
+    })
   }
 
   // No prompt: switch the persistent agent preference (original behavior).
@@ -529,23 +619,39 @@ export async function handleQuickAgentCommand({
     const previousAgentName =
       previousAgent.type !== 'none' ? previousAgent.agent : undefined
 
-    await setAgentForContext({ context, agentName: resolvedAgentName })
-
-    const modelInfo = await resolveAgentModelInfo({
-      context,
-      agentName: resolvedAgentName,
-    })
-    const scope =
-      context.isThread && context.sessionId ? 'session' : 'channel'
-
-    await command.editReply({
-      content: formatAgentPreferenceReply({
+    await waitForCurrentThreadIngress()
+    try {
+      await setAgentForContext({ context, agentName: resolvedAgentName })
+      const modelInfo = await resolveAgentModelInfo({
+        context,
         agentName: resolvedAgentName,
-        previousAgentName,
-        modelInfo,
-        scope,
-      }),
-    })
+      })
+      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({
@@ -565,11 +671,13 @@ async function handleQuickAgentWithPrompt({
   appId,
   fallbackAgentName,
   prompt,
+  variant,
 }: {
   command: ChatInputCommandInteraction
   appId: string
   fallbackAgentName: string
   prompt: string
+  variant?: string
 }): Promise<void> {
   const channel = command.channel
   if (!channel) {
@@ -615,7 +723,7 @@ async function handleQuickAgentWithPrompt({
 
     // Visible reply showing the one-shot prompt (not ephemeral, so it appears in thread).
     await command.reply({
-      content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+      content: `${QUEUE_PREFIX}**${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
       flags: SILENT_MESSAGE_FLAGS,
     })
 
@@ -626,6 +734,7 @@ async function handleQuickAgentWithPrompt({
       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.
@@ -662,7 +771,7 @@ async function handleQuickAgentWithPrompt({
       : baseThreadName
 
     const starterMessage = await channel.send({
-      content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+      content: `${QUEUE_PREFIX}**${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
       flags: SILENT_MESSAGE_FLAGS,
     })
 
@@ -696,12 +805,12 @@ async function handleQuickAgentWithPrompt({
       })
     }
 
-    const sessionDirectory = await (async () => {
-      if (!worktreePromise) return projectDirectory
-      const result = await worktreePromise
-      if (result instanceof Error) return projectDirectory
-      return result
-    })()
+    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()}`)
@@ -725,6 +834,7 @@ async function handleQuickAgentWithPrompt({
       agent: resolvedAgentName,
       appId,
       mode: 'opencode',
+      variant,
     })
   } else {
     await command.reply({
@@ -733,3 +843,69 @@ async function handleQuickAgentWithPrompt({
     })
   }
 }
+
+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,
+    })),
+  )
+}

package/src/commands/ask-question.test.ts

@@ -9,8 +9,11 @@ import {
   showAskUserQuestionDropdowns,
 } from './ask-question.js'
 
-function createFakeThread(): ThreadChannel {
+function createFakeThread({ failSend }: { failSend?: boolean } = {}): ThreadChannel {
   const send = vi.fn(async () => {
+    if (failSend) {
+      throw new Error('Missing Permissions')
+    }
     return { id: 'msg-1' }
   })
 
@@ -109,6 +112,50 @@ describe('ask-question', () => {
     expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3'])
   })
 
+  test('does not schedule a question expiry timer', async () => {
+    const timeoutSpy = vi.spyOn(globalThis, 'setTimeout')
+
+    await showAskUserQuestionDropdowns({
+      thread: createFakeThread(),
+      sessionId: 'ses-1',
+      directory: '/project',
+      requestId: 'req-no-ttl',
+      input: {
+        questions: [{
+          question: 'Choose one',
+          header: 'Pick',
+          options: [
+            { label: 'Alpha', description: 'A' },
+            { label: 'Beta', description: 'B' },
+          ],
+        }],
+      },
+    })
+
+    expect(timeoutSpy).not.toHaveBeenCalled()
+  })
+
+  test('drops the context when the dropdown message fails to send', async () => {
+    await showAskUserQuestionDropdowns({
+      thread: createFakeThread({ failSend: true }),
+      sessionId: 'ses-1',
+      directory: '/project',
+      requestId: 'req-send-fails',
+      input: {
+        questions: [{
+          question: 'Choose one',
+          header: 'Pick',
+          options: [
+            { label: 'Alpha', description: 'A' },
+            { label: 'Beta', description: 'B' },
+          ],
+        }],
+      },
+    })
+
+    expect(pendingQuestionContexts.size).toBe(0)
+  })
+
   test('requires every question to have an answer', () => {
     expect(areAllQuestionsAnswered({
       totalQuestions: 3,

package/src/commands/ask-question.ts

@@ -12,7 +12,9 @@ import {
 import crypto from 'node:crypto'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
 import { getOpencodeClient } from '../opencode.js'
+import { DiscordOperationError } from '../errors.js'
 import { createLogger, LogPrefix } from '../logger.js'
+import { QUEUE_PREFIX } from '../message-formatting.js'
 
 const logger = createLogger(LogPrefix.ASK_QUESTION)
 
@@ -44,8 +46,9 @@ type PendingQuestionContext = {
 }
 
 // Store pending question contexts by hash.
-// TTL prevents unbounded growth if user never answers a question.
-const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000
+// No TTL on purpose: a question can only be answered by the user, so expiring it
+// could only abort the run. Cleanup happens on answer, on a new user message, on
+// abort (abortActiveRunInternal), and on thread dispose.
 export const pendingQuestionContexts = new Map<string, PendingQuestionContext>()
 
 export function areAllQuestionsAnswered({
@@ -157,32 +160,6 @@ export async function showAskUserQuestionDropdowns({
   }
 
   pendingQuestionContexts.set(contextHash, context)
-  // On TTL expiry: hide the dropdown UI and abort the session so OpenCode
-  // unblocks. We intentionally do NOT call question.reply() — sending 'Other'
-  // made the model think the user chose an option when they didn't.
-  setTimeout(async () => {
-    const ctx = pendingQuestionContexts.get(contextHash)
-    if (!ctx) {
-      return
-    }
-    // Delete context first so the dropdown becomes inert immediately.
-    // Without this, a user clicking during the abort() await would still
-    // be accepted by handleAskQuestionSelectMenu, then abort() would
-    // kill that valid run.
-    deletePendingQuestionContextsForRequest({
-      threadId: ctx.thread.id,
-      requestId: ctx.requestId,
-    })
-    // Abort the session so OpenCode isn't stuck waiting for a reply
-    const client = getOpencodeClient(ctx.directory)
-    if (client) {
-      await client.session.abort({
-        sessionID: ctx.sessionId,
-      }).catch((error) => {
-        logger.error('Failed to abort session after question expiry:', error)
-      })
-    }
-  }, QUESTION_CONTEXT_TTL_MS).unref()
 
   // Send one message per question with its dropdown directly underneath
   for (let i = 0; i < input.questions.length; i++) {
@@ -219,11 +196,24 @@ export async function showAskUserQuestionDropdowns({
     const actionRow =
       new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(selectMenu)
 
-    await thread.send({
+    const sendResult = await thread.send({
       content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
       components: [actionRow],
       flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
-    })
+    }).catch((e) => new DiscordOperationError({ operation: 'sendQuestionDropdown', cause: e }))
+    // Without a visible dropdown the user can never answer, and there is no TTL
+    // to rescue the run, so drop the context and abort so OpenCode unblocks.
+    if (sendResult instanceof Error) {
+      logger.error('Failed to send question dropdown:', sendResult)
+      deletePendingQuestionContextsForRequest({ threadId: thread.id, requestId })
+      const client = getOpencodeClient(directory)
+      if (client) {
+        await client.session.abort({ sessionID: sessionId }).catch((error) => {
+          logger.error('Failed to abort session after question send failure:', error)
+        })
+      }
+      return
+    }
   }
 
   logger.log(
@@ -305,7 +295,7 @@ export async function handleAskQuestionSelectMenu(
   const username = interaction.user.globalName || interaction.user.username
   await sendThreadMessage(
     context.thread,
-    `» **${username}:** ${answeredText}`,
+    `${QUEUE_PREFIX}**${username}:** ${answeredText}`,
   )
 
   // Check if all questions are answered
@@ -414,7 +404,7 @@ export function parseAskUserQuestionTool(part: {
  *   the tool answer so the model sees the user's response. The caller should
  *   NOT also enqueue the message as a new prompt.
  *   Returns 'replied' on success, 'reply-failed' if the reply call fails
- *   (context kept pending so TTL can retry).
+ *   (context kept pending so the user can retry).
  */
 export async function cancelPendingQuestion(
   threadId: string,
@@ -466,7 +456,7 @@ export async function cancelPendingQuestion(
     logger.log(`Answered question ${context.requestId} with user message`)
   } catch (error) {
     logger.error('Failed to answer question:', error)
-    // Keep context pending so TTL can still fire.
+    // Keep context pending so the user can retry.
     // Caller should not consume the user message since reply failed.
     return 'reply-failed'
   }

package/src/commands/btw.ts

@@ -9,7 +9,13 @@ import {
   type ThreadChannel,
   MessageFlags,
 } from 'discord.js'
-import { getThreadSession, setThreadSession } from '../database.js'
+import {
+  getThreadSession,
+  setThreadSession,
+  getThreadWorktreeOrWorkspace,
+  createPendingWorkspace,
+  setWorkspaceReady,
+} from '../database.js'
 import {
   resolveWorkingDirectory,
   resolveTextChannel,
@@ -20,6 +26,7 @@ import { createLogger, LogPrefix } from '../logger.js'
 import type { CommandContext } from './types.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { copyCurrentSessionModel } from './model.js'
+import type { DiscordFileAttachment } from '../message-formatting.js'
 
 const logger = createLogger(LogPrefix.FORK)
 
@@ -28,18 +35,24 @@ export async function forkSessionToBtwThread({
   projectDirectory,
   sdkDirectory,
   prompt,
+  modelPrompt = prompt,
   userId,
   username,
   appId,
+  agent,
+  images,
 }: {
   sourceThread: ThreadChannel
   projectDirectory: string
   /** Worktree directory when forking from a worktree thread, otherwise same as projectDirectory */
   sdkDirectory: string
   prompt: string
+  modelPrompt?: string
   userId: string
   username: string
   appId: string | undefined
+  agent?: string
+  images?: DiscordFileAttachment[]
 }): Promise<{ thread: ThreadChannel; forkedSessionId: string } | Error> {
   // Parallelize: session lookup + opencode init + parent channel resolve are independent
   const [sessionId, getClientResult, textChannel] = await Promise.all([
@@ -61,7 +74,7 @@ export async function forkSessionToBtwThread({
   }
 
   // Fork must succeed before creating the Discord thread to avoid orphan threads
-  const forkResponse = await getClientResult().session.fork({ sessionID: sessionId })
+  const forkResponse = await getClientResult().session.fork({ sessionID: sessionId, directory: sdkDirectory })
   if (!forkResponse.data) {
     return new Error('Failed to fork session')
   }
@@ -74,7 +87,7 @@ export async function forkSessionToBtwThread({
     channelId,
     appId,
     getClient: getClientResult,
-    directory: projectDirectory,
+    directory: sdkDirectory,
   })
 
   const thread = await textChannel.threads.create({
@@ -85,11 +98,27 @@ export async function forkSessionToBtwThread({
 
   // DB mapping must complete before user-visible actions so the thread is routable
   await setThreadSession(thread.id, forkedSession.id)
+  const sourceWorkspace = await getThreadWorktreeOrWorkspace(sourceThread.id)
+  if (sourceWorkspace?.status === 'ready' && sourceWorkspace.workspace_directory) {
+    await createPendingWorkspace({
+      threadId: thread.id,
+      workspaceType: sourceWorkspace.workspace_type,
+      workspaceName: sourceWorkspace.workspace_name ?? '',
+      projectDirectory,
+    })
+    await setWorkspaceReady({
+      threadId: thread.id,
+      workspaceId: sourceWorkspace.workspace_id ?? undefined,
+      workspaceDirectory: sourceWorkspace.workspace_directory,
+    })
+  }
 
   // Parallelize: member add and status message are independent best-effort actions
   const sourceThreadLink = `<#${sourceThread.id}>`
   await Promise.all([
-    thread.members.add(userId).catch(() => {}),
+    thread.members.add(userId).catch((error) => {
+      logger.warn('Could not add fork member:', error)
+    }),
     sendThreadMessage(
       thread,
       `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`,
@@ -111,7 +140,7 @@ export async function forkSessionToBtwThread({
     `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
     `Do NOT send messages to the parent session unless the user explicitly asks you to.`,
     ``,
-    prompt,
+    modelPrompt,
   ].join('\n')
 
   const runtime = getOrCreateRuntime({
@@ -121,13 +150,19 @@ export async function forkSessionToBtwThread({
     sdkDirectory,
     channelId,
     appId,
+    sessionId: forkedSession.id,
   })
   await runtime.enqueueIncoming({
     prompt: wrappedPrompt,
+    agent,
+    images,
     userId,
     username,
     appId,
     mode: 'opencode',
+  }).catch(async (error) => {
+    logger.error('Fork dispatch failed:', error)
+    await sendThreadMessage(thread, 'Could not send the request to OpenCode. Send your request again in this thread.')
   })
 
   return {