kimaki 0.4.38 → 0.4.40

package/src/session-handler.ts

@@ -30,6 +30,7 @@ import {
   pendingQuestionContexts,
 } from './commands/ask-question.js'
 import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js'
+import * as errore from 'errore'
 
 const sessionLogger = createLogger('SESSION')
 const voiceLogger = createLogger('VOICE')
@@ -104,6 +105,10 @@ export async function abortAndRetrySession({
 
   // Also call the API abort endpoint
   const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  if (getClient instanceof Error) {
+    sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message)
+    return false
+  }
   try {
     await getClient().session.abort({ path: { id: sessionId } })
   } catch (e) {
@@ -183,6 +188,10 @@ export async function handleOpencodeSession({
   sessionLogger.log(`Using directory: ${directory}`)
 
   const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    await sendThreadMessage(thread, `✗ ${getClient.message}`)
+    return
+  }
 
   const serverEntry = getOpencodeServers().get(directory)
   const port = serverEntry?.port
@@ -392,6 +401,11 @@ export async function handleOpencodeSession({
   }
 
   const eventHandler = async () => {
+    // Subtask tracking: child sessionId → { label, assistantMessageId }
+    const subtaskSessions = new Map<string, { label: string; assistantMessageId?: string }>()
+    // Counts spawned tasks per agent type: "explore" → 2
+    const agentSpawnCounts: Record<string, number> = {}
+
     try {
       let assistantMessageId: string | undefined
 
@@ -399,6 +413,12 @@ export async function handleOpencodeSession({
         if (event.type === 'message.updated') {
           const msg = event.properties.info
 
+          // Track assistant message IDs for subtask sessions
+          const subtaskInfo = subtaskSessions.get(msg.sessionID)
+          if (subtaskInfo && msg.role === 'assistant') {
+            subtaskInfo.assistantMessageId = msg.id
+          }
+
           if (msg.sessionID !== session.id) {
             continue
           }
@@ -451,10 +471,55 @@ export async function handleOpencodeSession({
         } else if (event.type === 'message.part.updated') {
           const part = event.properties.part
 
-          if (part.sessionID !== session.id) {
+          // Check if this is a subtask event (child session we're tracking)
+          const subtaskInfo = subtaskSessions.get(part.sessionID)
+          const isSubtaskEvent = Boolean(subtaskInfo)
+
+          // Accept events from main session OR tracked subtask sessions
+          if (part.sessionID !== session.id && !isSubtaskEvent) {
             continue
           }
 
+          // For subtask events, send them immediately with prefix (don't buffer in currentParts)
+          if (isSubtaskEvent && subtaskInfo) {
+            // Skip parts that aren't useful to show (step-start, step-finish, pending tools)
+            if (part.type === 'step-start' || part.type === 'step-finish') {
+              continue
+            }
+            if (part.type === 'tool' && part.state.status === 'pending') {
+              continue
+            }
+            // Skip text parts - the outer agent will report the task result anyway
+            if (part.type === 'text') {
+              continue
+            }
+            // Only show parts from assistant messages (not user prompts sent to subtask)
+            // Skip if we haven't seen an assistant message yet, or if this part is from a different message
+            if (
+              !subtaskInfo.assistantMessageId ||
+              part.messageID !== subtaskInfo.assistantMessageId
+            ) {
+              continue
+            }
+
+            const content = formatPart(part, subtaskInfo.label)
+            if (content.trim() && !sentPartIds.has(part.id)) {
+              try {
+                const msg = await sendThreadMessage(thread, content + '\n\n')
+                sentPartIds.add(part.id)
+                getDatabase()
+                  .prepare(
+                    'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+                  )
+                  .run(part.id, msg.id, thread.id)
+              } catch (error) {
+                discordLogger.error(`ERROR: Failed to send subtask part ${part.id}:`, error)
+              }
+            }
+            continue
+          }
+
+          // Main session events: require matching assistantMessageId
           if (part.messageID !== assistantMessageId) {
             continue
           }
@@ -486,6 +551,20 @@ export async function handleOpencodeSession({
               }
             }
             await sendPartMessage(part)
+            // Track task tool and register child session when sessionId is available
+            if (part.tool === 'task' && !sentPartIds.has(part.id)) {
+              const description = (part.state.input?.description as string) || ''
+              const agent = (part.state.input?.subagent_type as string) || 'task'
+              const childSessionId = (part.state.metadata?.sessionId as string) || ''
+              if (description && childSessionId) {
+                agentSpawnCounts[agent] = (agentSpawnCounts[agent] || 0) + 1
+                const label = `${agent}-${agentSpawnCounts[agent]}`
+                subtaskSessions.set(childSessionId, { label, assistantMessageId: undefined })
+                const taskDisplay = `┣ task **${label}** _${description}_`
+                await sendThreadMessage(thread, taskDisplay + '\n\n')
+                sentPartIds.add(part.id)
+              }
+            }
           }
 
           // Show token usage for completed tools with large output (>5k tokens)
@@ -538,6 +617,7 @@ export async function handleOpencodeSession({
               stopTyping = startTyping()
             }, 300)
           }
+
         } else if (event.type === 'session.error') {
           sessionLogger.error(`ERROR:`, event.properties)
           if (event.properties.sessionID === session.id) {
@@ -670,15 +750,24 @@ export async function handleOpencodeSession({
               }).catch(async (e) => {
                 sessionLogger.error(`[QUEUE] Failed to process queued message:`, e)
                 const errorMsg = e instanceof Error ? e.message : String(e)
-                await sendThreadMessage(thread, `✗ Queued message failed: ${errorMsg.slice(0, 200)}`)
+                await sendThreadMessage(
+                  thread,
+                  `✗ Queued message failed: ${errorMsg.slice(0, 200)}`,
+                )
               })
             })
           }
         } else if (event.type === 'session.idle') {
+          const idleSessionId = event.properties.sessionID
           // Session is done processing - abort to signal completion
-          if (event.properties.sessionID === session.id) {
+          if (idleSessionId === session.id) {
             sessionLogger.log(`[SESSION IDLE] Session ${session.id} is idle, aborting`)
             abortController.abort('finished')
+          } else if (subtaskSessions.has(idleSessionId)) {
+            // Child session completed - clean up tracking
+            const subtask = subtaskSessions.get(idleSessionId)
+            sessionLogger.log(`[SUBTASK IDLE] Subtask "${subtask?.label}" completed`)
+            subtaskSessions.delete(idleSessionId)
           }
         }
       }
@@ -714,6 +803,32 @@ export async function handleOpencodeSession({
         let contextInfo = ''
 
         try {
+          // Fetch final token count from API since message.updated events can arrive
+          // after session.idle due to race conditions in event ordering
+          if (tokensUsedInSession === 0) {
+            const messagesResponse = await getClient().session.messages({
+              path: { id: session.id },
+            })
+            const messages = messagesResponse.data || []
+            const lastAssistant = [...messages]
+              .reverse()
+              .find((m) => m.info.role === 'assistant')
+            if (lastAssistant && 'tokens' in lastAssistant.info) {
+              const tokens = lastAssistant.info.tokens as {
+                input: number
+                output: number
+                reasoning: number
+                cache: { read: number; write: number }
+              }
+              tokensUsedInSession =
+                tokens.input +
+                tokens.output +
+                tokens.reasoning +
+                tokens.cache.read +
+                tokens.cache.write
+            }
+          }
+
           const providersResponse = await getClient().provider.list({ query: { directory } })
           const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID)
           const model = provider?.models?.[usedModel || '']

package/src/system-message.ts

@@ -85,6 +85,8 @@ you can create diagrams wrapping them in code blocks.
 
 IMPORTANT: At the end of each response, especially after completing a task or presenting a plan, use the question tool to offer the user clear options for what to do next.
 
+IMPORTANT: The question tool must be called last, after all text parts. If it is called before your final text response, the user will not see the text.
+
 Examples:
 - After showing a plan: offer "Start implementing?" with Yes/No options
 - After completing edits: offer "Commit changes?" with Yes/No options

package/src/tools.ts

@@ -13,6 +13,7 @@ import {
   type Provider,
 } from '@opencode-ai/sdk'
 import { createLogger } from './logger.js'
+import * as errore from 'errore'
 
 const toolsLogger = createLogger('TOOLS')
 
@@ -35,6 +36,9 @@ export async function getTools({
   }) => void
 }) {
   const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) {
+    throw new Error(getClient.message)
+  }
   const client = getClient()
 
   const markdownRenderer = new ShareMarkdown(client)
@@ -83,7 +87,7 @@ export async function getTools({
             },
           })
           .then(async (response) => {
-            const markdown = await markdownRenderer.generate({
+            const markdownResult = await markdownRenderer.generate({
               sessionID: sessionId,
               lastAssistantOnly: true,
             })
@@ -91,7 +95,7 @@ export async function getTools({
               sessionId,
               messageId: '',
               data: response.data,
-              markdown,
+              markdown: errore.unwrapOr(markdownResult, ''),
             })
           })
           .catch((error) => {
@@ -149,7 +153,7 @@ export async function getTools({
               },
             })
             .then(async (response) => {
-              const markdown = await markdownRenderer.generate({
+              const markdownResult = await markdownRenderer.generate({
                 sessionID: session.data.id,
                 lastAssistantOnly: true,
               })
@@ -157,7 +161,7 @@ export async function getTools({
                 sessionId: session.data.id,
                 messageId: '',
                 data: response.data,
-                markdown,
+                markdown: errore.unwrapOr(markdownResult, ''),
               })
             })
             .catch((error) => {
@@ -290,20 +294,26 @@ export async function getTools({
               ? 'completed'
               : 'in_progress'
 
-          const markdown = await markdownRenderer.generate({
+          const markdownResult = await markdownRenderer.generate({
             sessionID: sessionId,
             lastAssistantOnly: true,
           })
+          if (markdownResult instanceof Error) {
+            throw new Error(markdownResult.message)
+          }
 
           return {
             success: true,
-            markdown,
+            markdown: markdownResult,
             status,
           }
         } else {
-          const markdown = await markdownRenderer.generate({
+          const markdownResult = await markdownRenderer.generate({
             sessionID: sessionId,
           })
+          if (markdownResult instanceof Error) {
+            throw new Error(markdownResult.message)
+          }
 
           const messages = await getClient().session.messages({
             path: { id: sessionId },
@@ -319,7 +329,7 @@ export async function getTools({
 
           return {
             success: true,
-            markdown,
+            markdown: markdownResult,
             status,
           }
         }

package/src/voice-handler.ts

@@ -1,6 +1,7 @@
 // Discord voice channel connection and audio stream handler.
 // Manages joining/leaving voice channels, captures user audio, resamples to 16kHz,
 // and routes audio to the GenAI worker for real-time voice assistant interactions.
+import * as errore from 'errore'
 
 import {
   VoiceConnectionStatus,
@@ -34,6 +35,8 @@ import {
   SILENT_MESSAGE_FLAGS,
 } from './discord-utils.js'
 import { transcribeAudio } from './voice.js'
+import { FetchError } from './errors.js'
+
 import { createLogger } from './logger.js'
 
 const voiceLogger = createLogger('VOICE')
@@ -443,7 +446,15 @@ export async function processVoiceAttachment({
 
   await sendThreadMessage(thread, '🎤 Transcribing voice message...')
 
-  const audioResponse = await fetch(audioAttachment.url)
+  const audioResponse = await errore.tryAsync({
+    try: () => fetch(audioAttachment.url),
+    catch: (e) => new FetchError({ url: audioAttachment.url, cause: e }),
+  })
+  if (audioResponse instanceof Error) {
+    voiceLogger.error(`Failed to download audio attachment:`, audioResponse.message)
+    await sendThreadMessage(thread, `⚠️ Failed to download audio: ${audioResponse.message}`)
+    return null
+  }
   const audioBuffer = Buffer.from(await audioResponse.arrayBuffer())
 
   voiceLogger.log(`Downloaded ${audioBuffer.length} bytes, transcribing...`)
@@ -457,10 +468,9 @@ export async function processVoiceAttachment({
       const { stdout } = await execAsync('git ls-files | tree --fromfile -a', {
         cwd: projectDirectory,
       })
-      const result = stdout
 
-      if (result) {
-        transcriptionPrompt = `Discord voice message transcription. Project file structure:\n${result}\n\nPlease transcribe file names and paths accurately based on this context.`
+      if (stdout) {
+        transcriptionPrompt = `Discord voice message transcription. Project file structure:\n${stdout}\n\nPlease transcribe file names and paths accurately based on this context.`
         voiceLogger.log(`Added project context to transcription prompt`)
       }
     } catch (e) {
@@ -479,19 +489,25 @@ export async function processVoiceAttachment({
     }
   }
 
-  let transcription: string
-  try {
-    transcription = await transcribeAudio({
-      audio: audioBuffer,
-      prompt: transcriptionPrompt,
-      geminiApiKey,
-      directory: projectDirectory,
-      currentSessionContext,
-      lastSessionContext,
+  const transcription = await transcribeAudio({
+    audio: audioBuffer,
+    prompt: transcriptionPrompt,
+    geminiApiKey,
+    directory: projectDirectory,
+    currentSessionContext,
+    lastSessionContext,
+  })
+
+  if (transcription instanceof Error) {
+    const errMsg = errore.matchError(transcription, {
+      ApiKeyMissingError: (e) => e.message,
+      InvalidAudioFormatError: (e) => e.message,
+      TranscriptionError: (e) => e.message,
+      EmptyTranscriptionError: (e) => e.message,
+      NoResponseContentError: (e) => e.message,
+      NoToolResponseError: (e) => e.message,
     })
-  } catch (error) {
-    const errMsg = error instanceof Error ? error.message : String(error)
-    voiceLogger.error(`Transcription failed:`, error)
+    voiceLogger.error(`Transcription failed:`, transcription)
     await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`)
     return null
   }
@@ -503,14 +519,23 @@ export async function processVoiceAttachment({
   if (isNewThread) {
     const threadName = transcription.replace(/\s+/g, ' ').trim().slice(0, 80)
     if (threadName) {
-      try {
-        await Promise.race([
-          thread.setName(threadName),
-          new Promise((resolve) => setTimeout(resolve, 2000)),
-        ])
+      const renamed = await Promise.race([
+        errore.tryAsync({
+          try: () => thread.setName(threadName),
+          catch: (e) => e as Error,
+        }),
+        new Promise<null>((resolve) => {
+          setTimeout(() => {
+            resolve(null)
+          }, 2000)
+        }),
+      ])
+      if (renamed === null) {
+        voiceLogger.log(`Thread name update timed out`)
+      } else if (renamed instanceof Error) {
+        voiceLogger.log(`Could not update thread name:`, renamed.message)
+      } else {
         voiceLogger.log(`Updated thread name to: "${threadName}"`)
-      } catch (e) {
-        voiceLogger.log(`Could not update thread name:`, e)
       }
     }
   }