kimaki 0.4.38 → 0.4.39

package/dist/opencode.js

@@ -1,12 +1,15 @@
 // OpenCode server process manager.
 // Spawns and maintains OpenCode API servers per project directory,
 // handles automatic restarts on failure, and provides typed SDK clients.
+// Uses errore for type-safe error handling.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import net from 'node:net';
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { createOpencodeClient as createOpencodeClientV2, } from '@opencode-ai/sdk/v2';
+import * as errore from 'errore';
 import { createLogger } from './logger.js';
+import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
 const opencodeLogger = createLogger('OPENCODE');
 const opencodeServers = new Map();
 const serverRetryCount = new Map();
@@ -30,42 +33,33 @@ async function getOpenPort() {
 }
 async function waitForServer(port, maxAttempts = 30) {
     for (let i = 0; i < maxAttempts; i++) {
-        try {
-            const endpoints = [
-                `http://127.0.0.1:${port}/api/health`,
-                `http://127.0.0.1:${port}/`,
-                `http://127.0.0.1:${port}/api`,
-            ];
-            for (const endpoint of endpoints) {
-                try {
-                    const response = await fetch(endpoint);
-                    if (response.status < 500) {
-                        return true;
-                    }
-                    const body = await response.text();
-                    // Fatal errors that won't resolve with retrying
-                    if (body.includes('BunInstallFailedError')) {
-                        throw new Error(`Server failed to start: ${body.slice(0, 200)}`);
-                    }
-                }
-                catch (e) {
-                    // Re-throw fatal errors
-                    if (e.message?.includes('Server failed to start')) {
-                        throw e;
-                    }
-                }
+        const endpoints = [
+            `http://127.0.0.1:${port}/api/health`,
+            `http://127.0.0.1:${port}/`,
+            `http://127.0.0.1:${port}/api`,
+        ];
+        for (const endpoint of endpoints) {
+            const response = await errore.tryAsync({
+                try: () => fetch(endpoint),
+                catch: (e) => new FetchError({ url: endpoint, cause: e }),
+            });
+            if (errore.isError(response)) {
+                // Connection refused or other transient errors - continue polling
+                opencodeLogger.debug(`Server polling attempt failed: ${response.message}`);
+                continue;
             }
-        }
-        catch (e) {
-            // Re-throw fatal errors that won't resolve with retrying
-            if (e.message?.includes('Server failed to start')) {
-                throw e;
+            if (response.status < 500) {
+                return true;
+            }
+            const body = await response.text();
+            // Fatal errors that won't resolve with retrying
+            if (body.includes('BunInstallFailedError')) {
+                return new ServerStartError({ port, reason: body.slice(0, 200) });
             }
-            opencodeLogger.debug(`Server polling attempt failed: ${e.message}`);
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    throw new Error(`Server did not start on port ${port} after ${maxAttempts} seconds`);
+    return new ServerStartError({ port, reason: `Server did not start after ${maxAttempts} seconds` });
 }
 export async function initializeOpencodeForDirectory(directory) {
     const existing = opencodeServers.get(directory);
@@ -74,17 +68,20 @@ export async function initializeOpencodeForDirectory(directory) {
         return () => {
             const entry = opencodeServers.get(directory);
             if (!entry?.client) {
-                throw new Error(`OpenCode server for directory "${directory}" is in an error state (no client available)`);
+                throw new ServerNotReadyError({ directory });
             }
             return entry.client;
         };
     }
     // Verify directory exists and is accessible before spawning
-    try {
-        fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK);
-    }
-    catch {
-        throw new Error(`Directory does not exist or is not accessible: ${directory}`);
+    const accessCheck = errore.tryFn({
+        try: () => {
+            fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK);
+        },
+        catch: () => new DirectoryNotAccessibleError({ directory }),
+    });
+    if (errore.isError(accessCheck)) {
+        return accessCheck;
     }
     const port = await getOpenPort();
     const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
@@ -127,8 +124,10 @@ export async function initializeOpencodeForDirectory(directory) {
             if (retryCount < 5) {
                 serverRetryCount.set(directory, retryCount + 1);
                 opencodeLogger.log(`Restarting server for directory: ${directory} (attempt ${retryCount + 1}/5)`);
-                initializeOpencodeForDirectory(directory).catch((e) => {
-                    opencodeLogger.error(`Failed to restart opencode server:`, e);
+                initializeOpencodeForDirectory(directory).then((result) => {
+                    if (errore.isError(result)) {
+                        opencodeLogger.error(`Failed to restart opencode server:`, result);
+                    }
                 });
             }
             else {
@@ -139,18 +138,16 @@ export async function initializeOpencodeForDirectory(directory) {
             serverRetryCount.delete(directory);
         }
     });
-    try {
-        await waitForServer(port);
-        opencodeLogger.log(`Server ready on port ${port}`);
-    }
-    catch (e) {
+    const waitResult = await waitForServer(port);
+    if (errore.isError(waitResult)) {
         // Dump buffered logs on failure
         opencodeLogger.error(`Server failed to start for ${directory}:`);
         for (const line of logBuffer) {
             opencodeLogger.error(`  ${line}`);
         }
-        throw e;
+        return waitResult;
     }
+    opencodeLogger.log(`Server ready on port ${port}`);
     const baseUrl = `http://127.0.0.1:${port}`;
     const fetchWithTimeout = (request) => fetch(request, {
         // @ts-ignore
@@ -173,7 +170,7 @@ export async function initializeOpencodeForDirectory(directory) {
     return () => {
         const entry = opencodeServers.get(directory);
         if (!entry?.client) {
-            throw new Error(`OpenCode server for directory "${directory}" is in an error state (no client available)`);
+            throw new ServerNotReadyError({ directory });
         }
         return entry.client;
     };

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') {
@@ -499,11 +570,18 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     }
                 }
                 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);
+                    }
                 }
             }
         }
@@ -537,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 || ''];

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}"`);
             }
         }
     }