kimaki 0.4.37 → 0.4.39

package/dist/session-handler.js

@@ -11,6 +11,7 @@ import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
 import { showAskUserQuestionDropdowns, cancelPendingQuestion, 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');
 const discordLogger = createLogger('DISCORD');
@@ -48,6 +49,10 @@ export async function abortAndRetrySession({ sessionId, thread, projectDirectory
     controller.abort('model-change');
     // Also call the API abort endpoint
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (errore.isError(getClient)) {
+        sessionLogger.error(`[ABORT+RETRY] Failed to initialize OpenCode client:`, getClient.message);
+        return false;
+    }
     try {
         await getClient().session.abort({ path: { id: sessionId } });
     }
@@ -93,6 +98,10 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const directory = projectDirectory || process.cwd();
     sessionLogger.log(`Using directory: ${directory}`);
     const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        await sendThreadMessage(thread, `✗ ${getClient.message}`);
+        return;
+    }
     const serverEntry = getOpencodeServers().get(directory);
     const port = serverEntry?.port;
     const row = getDatabase()
@@ -258,11 +267,20 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         }
     };
     const eventHandler = async () => {
+        // Subtask tracking: child sessionId → { label, assistantMessageId }
+        const subtaskSessions = new Map();
+        // Counts spawned tasks per agent type: "explore" → 2
+        const agentSpawnCounts = {};
         try {
             let assistantMessageId;
             for await (const event of events) {
                 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;
                     }
@@ -309,9 +327,48 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 }
                 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;
                     }
@@ -339,6 +396,20 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                             }
                         }
                         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 || '';
+                            const agent = part.state.input?.subagent_type || 'task';
+                            const childSessionId = part.state.metadata?.sessionId || '';
+                            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)
                     if (part.type === 'tool' && part.state.status === 'completed') {
@@ -473,13 +544,44 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         requestId: questionRequest.id,
                         input: { questions: questionRequest.questions },
                     });
+                    // Process queued messages if any - queued message will cancel the pending question
+                    const queue = messageQueue.get(thread.id);
+                    if (queue && queue.length > 0) {
+                        const nextMessage = queue.shift();
+                        if (queue.length === 0) {
+                            messageQueue.delete(thread.id);
+                        }
+                        sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
+                        await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
+                        // handleOpencodeSession will call cancelPendingQuestion, which cancels the dropdown
+                        setImmediate(() => {
+                            handleOpencodeSession({
+                                prompt: nextMessage.prompt,
+                                thread,
+                                projectDirectory: directory,
+                                images: nextMessage.images,
+                                channelId,
+                            }).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)}`);
+                            });
+                        });
+                    }
                 }
                 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);
+                    }
                 }
             }
         }
@@ -513,6 +615,26 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : '';
                 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;
+                            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 || ''];
@@ -581,9 +703,20 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         })();
         const parts = [{ type: 'text', text: promptWithImagePaths }, ...images];
         sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+        // Get agent preference: session-level overrides channel-level
+        const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined);
+        if (agentPreference) {
+            sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
+        }
         // Get model preference: session-level overrides channel-level
+        // BUT: if an agent is set, don't pass model param so the agent's model takes effect
         const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
         const modelParam = (() => {
+            // When an agent is set, let the agent's model config take effect
+            if (agentPreference) {
+                sessionLogger.log(`[MODEL] Skipping model param, agent "${agentPreference}" controls model`);
+                return undefined;
+            }
             if (!modelPreference) {
                 return undefined;
             }
@@ -595,11 +728,6 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
             return { providerID, modelID };
         })();
-        // Get agent preference: session-level overrides channel-level
-        const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined);
-        if (agentPreference) {
-            sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
-        }
         // Use session.command API for slash commands, session.prompt for regular messages
         const response = command
             ? await getClient().session.command({
@@ -650,8 +778,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         return { sessionID: session.id, result: response.data, port };
     }
     catch (error) {
-        sessionLogger.error(`ERROR: Failed to send prompt:`, error);
         if (!isAbortError(error, abortController.signal)) {
+            sessionLogger.error(`ERROR: Failed to send prompt:`, error);
             abortController.abort('error');
             if (originalMessage) {
                 try {

package/dist/system-message.js

@@ -76,6 +76,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/dist/tools.js

@@ -7,6 +7,7 @@ import { spawn } from 'node:child_process';
 import net from 'node:net';
 import { createOpencodeClient, } from '@opencode-ai/sdk';
 import { createLogger } from './logger.js';
+import * as errore from 'errore';
 const toolsLogger = createLogger('TOOLS');
 import { ShareMarkdown } from './markdown.js';
 import { formatDistanceToNow } from './utils.js';
@@ -14,6 +15,9 @@ import pc from 'picocolors';
 import { initializeOpencodeForDirectory, getOpencodeSystemMessage } from './discord-bot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
+    if (errore.isError(getClient)) {
+        throw new Error(getClient.message);
+    }
     const client = getClient();
     const markdownRenderer = new ShareMarkdown(client);
     const providersResponse = await client.config.providers({});
@@ -55,7 +59,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     },
                 })
                     .then(async (response) => {
-                    const markdown = await markdownRenderer.generate({
+                    const markdownResult = await markdownRenderer.generate({
                         sessionID: sessionId,
                         lastAssistantOnly: true,
                     });
@@ -63,7 +67,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         sessionId,
                         messageId: '',
                         data: response.data,
-                        markdown,
+                        markdown: errore.unwrapOr(markdownResult, ''),
                     });
                 })
                     .catch((error) => {
@@ -116,7 +120,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         },
                     })
                         .then(async (response) => {
-                        const markdown = await markdownRenderer.generate({
+                        const markdownResult = await markdownRenderer.generate({
                             sessionID: session.data.id,
                             lastAssistantOnly: true,
                         });
@@ -124,7 +128,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                             sessionId: session.data.id,
                             messageId: '',
                             data: response.data,
-                            markdown,
+                            markdown: errore.unwrapOr(markdownResult, ''),
                         });
                     })
                         .catch((error) => {
@@ -240,20 +244,26 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     const status = 'completed' in lastMessage.info.time && lastMessage.info.time.completed
                         ? 'completed'
                         : 'in_progress';
-                    const markdown = await markdownRenderer.generate({
+                    const markdownResult = await markdownRenderer.generate({
                         sessionID: sessionId,
                         lastAssistantOnly: true,
                     });
+                    if (errore.isError(markdownResult)) {
+                        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 (errore.isError(markdownResult)) {
+                        throw new Error(markdownResult.message);
+                    }
                     const messages = await getClient().session.messages({
                         path: { id: sessionId },
                     });
@@ -266,7 +276,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         : 'completed';
                     return {
                         success: true,
-                        markdown,
+                        markdown: markdownResult,
                         status,
                     };
                 }

package/dist/voice-handler.js

@@ -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, EndBehaviorType, joinVoiceChannel, entersState, } from '@discordjs/voice';
 import { exec } from 'node:child_process';
 import fs, { createWriteStream } from 'node:fs';
@@ -15,6 +16,7 @@ import { createGenAIWorker } from './genai-worker-wrapper.js';
 import { getDatabase } from './database.js';
 import { sendThreadMessage, escapeDiscordFormatting, 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');
 export const voiceConnections = new Map();
@@ -320,7 +322,15 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         return null;
     voiceLogger.log(`Detected audio attachment: ${audioAttachment.name} (${audioAttachment.contentType})`);
     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 (errore.isError(audioResponse)) {
+        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...`);
     let transcriptionPrompt = 'Discord voice message transcription';
@@ -331,9 +341,8 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             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`);
             }
         }
@@ -350,20 +359,24 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             geminiApiKey = apiKeys.gemini_api_key;
         }
     }
-    let transcription;
-    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 (errore.isError(transcription)) {
+        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;
     }
@@ -371,15 +384,25 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
     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)),
-                ]);
-                voiceLogger.log(`Updated thread name to: "${threadName}"`);
+            const renamed = await Promise.race([
+                errore.tryAsync({
+                    try: () => thread.setName(threadName),
+                    catch: (e) => e,
+                }),
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(null);
+                    }, 2000);
+                }),
+            ]);
+            if (renamed === null) {
+                voiceLogger.log(`Thread name update timed out`);
             }
-            catch (e) {
-                voiceLogger.log(`Could not update thread name:`, e);
+            else if (errore.isError(renamed)) {
+                voiceLogger.log(`Could not update thread name:`, renamed.message);
+            }
+            else {
+                voiceLogger.log(`Updated thread name to: "${threadName}"`);
             }
         }
     }