kimaki 0.4.24 → 0.4.26

package/dist/opencode.js

@@ -1,6 +1,11 @@
+// OpenCode server process manager.
+// Spawns and maintains OpenCode API servers per project directory,
+// handles automatic restarts on failure, and provides typed SDK clients.
 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 { createLogger } from './logger.js';
 const opencodeLogger = createLogger('OPENCODE');
 const opencodeServers = new Map();
@@ -27,22 +32,37 @@ async function waitForServer(port, maxAttempts = 30) {
     for (let i = 0; i < maxAttempts; i++) {
         try {
             const endpoints = [
-                `http://localhost:${port}/api/health`,
-                `http://localhost:${port}/`,
-                `http://localhost:${port}/api`,
+                `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) {
-                        opencodeLogger.log(`Server ready on port `);
                         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;
+                    }
                 }
-                catch (e) { }
             }
         }
-        catch (e) { }
+        catch (e) {
+            // Re-throw fatal errors that won't resolve with retrying
+            if (e.message?.includes('Server failed to start')) {
+                throw e;
+            }
+            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`);
@@ -59,8 +79,16 @@ export async function initializeOpencodeForDirectory(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 port = await getOpenPort();
-    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
+    const opencodeBinDir = `${process.env.HOME}/.opencode/bin`;
+    const opencodeCommand = process.env.OPENCODE_PATH || `${opencodeBinDir}/opencode`;
     const serverProcess = spawn(opencodeCommand, ['serve', '--port', port.toString()], {
         stdio: 'pipe',
         detached: false,
@@ -80,14 +108,17 @@ export async function initializeOpencodeForDirectory(directory) {
             OPENCODE_PORT: port.toString(),
         },
     });
+    // Buffer logs until we know if server started successfully
+    const logBuffer = [];
+    logBuffer.push(`Spawned opencode serve --port ${port} in ${directory} (pid: ${serverProcess.pid})`);
     serverProcess.stdout?.on('data', (data) => {
-        opencodeLogger.log(`opencode ${directory}: ${data.toString().trim()}`);
+        logBuffer.push(`[stdout] ${data.toString().trim()}`);
     });
     serverProcess.stderr?.on('data', (data) => {
-        opencodeLogger.error(`opencode ${directory}: ${data.toString().trim()}`);
+        logBuffer.push(`[stderr] ${data.toString().trim()}`);
     });
     serverProcess.on('error', (error) => {
-        opencodeLogger.error(`Failed to start server on port :`, port, error);
+        logBuffer.push(`Failed to start server on port ${port}: ${error}`);
     });
     serverProcess.on('exit', (code) => {
         opencodeLogger.log(`Opencode server on ${directory} exited with code:`, code);
@@ -109,17 +140,35 @@ export async function initializeOpencodeForDirectory(directory) {
             serverRetryCount.delete(directory);
         }
     });
-    await waitForServer(port);
+    try {
+        await waitForServer(port);
+        opencodeLogger.log(`Server ready on port ${port}`);
+    }
+    catch (e) {
+        // Dump buffered logs on failure
+        opencodeLogger.error(`Server failed to start for ${directory}:`);
+        for (const line of logBuffer) {
+            opencodeLogger.error(`  ${line}`);
+        }
+        throw e;
+    }
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const fetchWithTimeout = (request) => fetch(request, {
+        // @ts-ignore
+        timeout: false,
+    });
     const client = createOpencodeClient({
-        baseUrl: `http://localhost:${port}`,
-        fetch: (request) => fetch(request, {
-            // @ts-ignore
-            timeout: false,
-        }),
+        baseUrl,
+        fetch: fetchWithTimeout,
+    });
+    const clientV2 = createOpencodeClientV2({
+        baseUrl,
+        fetch: fetchWithTimeout,
     });
     opencodeServers.set(directory, {
         process: serverProcess,
         client,
+        clientV2,
         port,
     });
     return () => {
@@ -133,3 +182,11 @@ export async function initializeOpencodeForDirectory(directory) {
 export function getOpencodeServers() {
     return opencodeServers;
 }
+export function getOpencodeServerPort(directory) {
+    const entry = opencodeServers.get(directory);
+    return entry?.port ?? null;
+}
+export function getOpencodeClientV2(directory) {
+    const entry = opencodeServers.get(directory);
+    return entry?.clientV2 ?? null;
+}

package/dist/session-handler.js

@@ -1,30 +1,90 @@
+// OpenCode session lifecycle manager.
+// Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
+// Handles streaming events, permissions, abort signals, and message queuing.
 import prettyMilliseconds from 'pretty-ms';
-import { getDatabase, getSessionModel, getChannelModel } from './database.js';
-import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
-import { sendThreadMessage } from './discord-utils.js';
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js';
+import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
 import { getOpencodeSystemMessage } from './system-message.js';
 import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
+import { showAskUserQuestionDropdowns } from './commands/ask-question.js';
 const sessionLogger = createLogger('SESSION');
 const voiceLogger = createLogger('VOICE');
 const discordLogger = createLogger('DISCORD');
-export function parseSlashCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith('/')) {
-        return { isCommand: false };
+export const abortControllers = new Map();
+export const pendingPermissions = new Map();
+// Queue of messages waiting to be sent after current response finishes
+// Key is threadId, value is array of queued messages
+export const messageQueue = new Map();
+export function addToQueue({ threadId, message, }) {
+    const queue = messageQueue.get(threadId) || [];
+    queue.push(message);
+    messageQueue.set(threadId, queue);
+    return queue.length;
+}
+export function getQueueLength(threadId) {
+    return messageQueue.get(threadId)?.length || 0;
+}
+export function clearQueue(threadId) {
+    messageQueue.delete(threadId);
+}
+/**
+ * Abort a running session and retry with the last user message.
+ * Used when model preference changes mid-request.
+ * Fetches last user message from OpenCode API instead of tracking in memory.
+ * @returns true if aborted and retry scheduled, false if no active request
+ */
+export async function abortAndRetrySession({ sessionId, thread, projectDirectory, }) {
+    const controller = abortControllers.get(sessionId);
+    if (!controller) {
+        sessionLogger.log(`[ABORT+RETRY] No active request for session ${sessionId}`);
+        return false;
     }
-    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
-    if (!match) {
-        return { isCommand: false };
+    sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`);
+    // Abort with special reason so we don't show "completed" message
+    controller.abort('model-change');
+    // Also call the API abort endpoint
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    try {
+        await getClient().session.abort({ path: { id: sessionId } });
+    }
+    catch (e) {
+        sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, e);
     }
-    const command = match[1];
-    const args = match[2]?.trim() || '';
-    return { isCommand: true, command, arguments: args };
+    // Small delay to let the abort propagate
+    await new Promise((resolve) => { setTimeout(resolve, 300); });
+    // Fetch last user message from API
+    sessionLogger.log(`[ABORT+RETRY] Fetching last user message for session ${sessionId}`);
+    const messagesResponse = await getClient().session.messages({ path: { id: sessionId } });
+    const messages = messagesResponse.data || [];
+    const lastUserMessage = [...messages].reverse().find((m) => m.info.role === 'user');
+    if (!lastUserMessage) {
+        sessionLogger.log(`[ABORT+RETRY] No user message found in session ${sessionId}`);
+        return false;
+    }
+    // Extract text and images from parts
+    const textPart = lastUserMessage.parts.find((p) => p.type === 'text');
+    const prompt = textPart?.text || '';
+    const images = lastUserMessage.parts.filter((p) => p.type === 'file');
+    sessionLogger.log(`[ABORT+RETRY] Re-triggering session ${sessionId} with new model`);
+    // Use setImmediate to avoid blocking
+    setImmediate(() => {
+        handleOpencodeSession({
+            prompt,
+            thread,
+            projectDirectory,
+            images,
+        }).catch(async (e) => {
+            sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, e);
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            await sendThreadMessage(thread, `✗ Failed to retry with new model: ${errorMsg.slice(0, 200)}`);
+        });
+    });
+    return true;
 }
-export const abortControllers = new Map();
-export const pendingPermissions = new Map();
-export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], parsedCommand, channelId, }) {
+export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], channelId, command, }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     const sessionStartTime = Date.now();
     const directory = projectDirectory || process.cwd();
@@ -103,9 +163,12 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
         sessionLogger.log(`[DEBOUNCE] Aborted before subscribe, exiting`);
         return;
     }
-    const eventsResult = await getClient().event.subscribe({
-        signal: abortController.signal,
-    });
+    // Use v2 client for event subscription (has proper types for question.asked events)
+    const clientV2 = getOpencodeClientV2(directory);
+    if (!clientV2) {
+        throw new Error(`OpenCode v2 client not found for directory: ${directory}`);
+    }
+    const eventsResult = await clientV2.event.subscribe({ directory }, { signal: abortController.signal });
     if (abortController.signal.aborted) {
         sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`);
         return;
@@ -120,6 +183,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     let stopTyping = null;
     let usedModel;
     let usedProviderID;
+    let usedAgent;
     let tokensUsedInSession = 0;
     let lastDisplayedContextPercentage = 0;
     let modelContextLimit;
@@ -159,7 +223,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
-            discordLogger.log(`SKIP: Part ${part.id} has no content`);
+            // discordLogger.log(`SKIP: Part ${part.id} has no content`)
             return;
         }
         if (sentPartIds.has(part.id)) {
@@ -193,6 +257,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         assistantMessageId = msg.id;
                         usedModel = msg.modelID;
                         usedProviderID = msg.providerID;
+                        usedAgent = msg.mode;
                         if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
                             if (!modelContextLimit) {
                                 try {
@@ -212,7 +277,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                                 const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
                                 if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
                                     lastDisplayedContextPercentage = thresholdCrossed;
-                                    await sendThreadMessage(thread, `◼︎ context usage ${currentPercentage}%`);
+                                    await sendThreadMessage(thread, `⬥ context usage ${currentPercentage}%`);
                                 }
                             }
                         }
@@ -278,19 +343,16 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     }
                     break;
                 }
-                else if (event.type === 'permission.updated') {
+                else if (event.type === 'permission.asked') {
                     const permission = event.properties;
                     if (permission.sessionID !== session.id) {
                         voiceLogger.log(`[PERMISSION IGNORED] Permission for different session (expected: ${session.id}, got: ${permission.sessionID})`);
                         continue;
                     }
-                    sessionLogger.log(`Permission requested: type=${permission.type}, title=${permission.title}`);
-                    const patternStr = Array.isArray(permission.pattern)
-                        ? permission.pattern.join(', ')
-                        : permission.pattern || '';
+                    sessionLogger.log(`Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`);
+                    const patternStr = permission.patterns.join(', ');
                     const permissionMessage = await sendThreadMessage(thread, `⚠️ **Permission Required**\n\n` +
-                        `**Type:** \`${permission.type}\`\n` +
-                        `**Action:** ${permission.title}\n` +
+                        `**Type:** \`${permission.permission}\`\n` +
                         (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
                         `\nUse \`/accept\` or \`/reject\` to respond.`);
                     pendingPermissions.set(thread.id, {
@@ -300,16 +362,31 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     });
                 }
                 else if (event.type === 'permission.replied') {
-                    const { permissionID, response, sessionID } = event.properties;
+                    const { requestID, reply, sessionID } = event.properties;
                     if (sessionID !== session.id) {
                         continue;
                     }
-                    sessionLogger.log(`Permission ${permissionID} replied with: ${response}`);
+                    sessionLogger.log(`Permission ${requestID} replied with: ${reply}`);
                     const pending = pendingPermissions.get(thread.id);
-                    if (pending && pending.permission.id === permissionID) {
+                    if (pending && pending.permission.id === requestID) {
                         pendingPermissions.delete(thread.id);
                     }
                 }
+                else if (event.type === 'question.asked') {
+                    const questionRequest = event.properties;
+                    if (questionRequest.sessionID !== session.id) {
+                        sessionLogger.log(`[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`);
+                        continue;
+                    }
+                    sessionLogger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+                    await showAskUserQuestionDropdowns({
+                        thread,
+                        sessionId: session.id,
+                        directory,
+                        requestId: questionRequest.id,
+                        input: { questions: questionRequest.questions },
+                    });
+                }
             }
         }
         catch (e) {
@@ -340,6 +417,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
+                const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : '';
                 let contextInfo = '';
                 try {
                     const providersResponse = await getClient().provider.list({ query: { directory } });
@@ -353,8 +431,34 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 catch (e) {
                     sessionLogger.error('Failed to fetch provider info for context percentage:', e);
                 }
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`);
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}${agentInfo}`, { flags: NOTIFY_MESSAGE_FLAGS });
                 sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
+                // Process queued messages after completion
+                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] Processing queued message from ${nextMessage.username}`);
+                    // Show that queued message is being sent
+                    await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
+                    // Send the queued message as a new prompt (recursive call)
+                    // Use setImmediate to avoid blocking and allow this finally to complete
+                    setImmediate(() => {
+                        handleOpencodeSession({
+                            prompt: nextMessage.prompt,
+                            thread,
+                            projectDirectory,
+                            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 {
                 sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
@@ -368,49 +472,58 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             return;
         }
         stopTyping = startTyping();
-        let response;
-        if (parsedCommand?.isCommand) {
-            sessionLogger.log(`[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`);
-            response = await getClient().session.command({
+        voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+        // append image paths to prompt so ai knows where they are on disk
+        const promptWithImagePaths = (() => {
+            if (images.length === 0) {
+                return prompt;
+            }
+            sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
+            const imagePathsList = images.map((img) => `- ${img.filename}: ${img.url}`).join('\n');
+            return `${prompt}\n\n**attached images:**\n${imagePathsList}`;
+        })();
+        const parts = [{ type: 'text', text: promptWithImagePaths }, ...images];
+        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+        // Get model preference: session-level overrides channel-level
+        const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
+        const modelParam = (() => {
+            if (!modelPreference) {
+                return undefined;
+            }
+            const [providerID, ...modelParts] = modelPreference.split('/');
+            const modelID = modelParts.join('/');
+            if (!providerID || !modelID) {
+                return undefined;
+            }
+            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({
                 path: { id: session.id },
                 body: {
-                    command: parsedCommand.command,
-                    arguments: parsedCommand.arguments,
+                    command: command.name,
+                    arguments: command.arguments,
+                    agent: agentPreference,
                 },
                 signal: abortController.signal,
-            });
-        }
-        else {
-            voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
-            if (images.length > 0) {
-                sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
-            }
-            const parts = [{ type: 'text', text: prompt }, ...images];
-            sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
-            // Get model preference: session-level overrides channel-level
-            const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
-            const modelParam = (() => {
-                if (!modelPreference) {
-                    return undefined;
-                }
-                const [providerID, ...modelParts] = modelPreference.split('/');
-                const modelID = modelParts.join('/');
-                if (!providerID || !modelID) {
-                    return undefined;
-                }
-                sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
-                return { providerID, modelID };
-            })();
-            response = await getClient().session.prompt({
+            })
+            : await getClient().session.prompt({
                 path: { id: session.id },
                 body: {
                     parts,
                     system: getOpencodeSystemMessage({ sessionId: session.id }),
                     model: modelParam,
+                    agent: agentPreference,
                 },
                 signal: abortController.signal,
             });
-        }
         if (response.error) {
             const errorMessage = (() => {
                 const err = response.error;

package/dist/system-message.js

@@ -1,3 +1,6 @@
+// OpenCode system prompt generator.
+// Creates the system message injected into every OpenCode session,
+// including Discord-specific formatting rules, diff commands, and permissions info.
 export function getOpencodeSystemMessage({ sessionId }) {
     return `
 The user is reading your messages from inside Discord, via kimaki.xyz
@@ -14,24 +17,6 @@ Only users with these Discord permissions can send messages to the bot:
 - Manage Server permission
 - "Kimaki" role (case-insensitive)
 
-## changing the model
-
-To change the model used by OpenCode, edit the project's \`opencode.json\` config file and set the \`model\` field:
-
-\`\`\`json
-{
-  "model": "anthropic/claude-sonnet-4-20250514"
-}
-\`\`\`
-
-Examples:
-- \`"anthropic/claude-sonnet-4-20250514"\` - Claude Sonnet 4
-- \`"anthropic/claude-opus-4-20250514"\` - Claude Opus 4
-- \`"openai/gpt-4o"\` - GPT-4o
-- \`"google/gemini-2.5-pro"\` - Gemini 2.5 Pro
-
-Format is \`provider/model-name\`. You can also set \`small_model\` for tasks like title generation.
-
 ## uploading files to discord
 
 To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
@@ -52,7 +37,9 @@ bunx critique web -- path/to/file1.ts path/to/file2.ts
 
 You can also show latest commit changes using:
 
-bunx critique web HEAD~1
+bunx critique web HEAD
+
+bunx critique web HEAD~1 to get the one before last
 
 Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
 
@@ -66,27 +53,9 @@ the max heading level is 3, so do not use ####
 
 headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
 
-## tables
-
-discord does NOT support markdown gfm tables.
-
-so instead of using full markdown tables ALWAYS show code snippets with space aligned cells:
-
-\`\`\`
-Item        Qty   Price
-----------  ---   -----
-Apples      10    $5
-Oranges     3     $2
-\`\`\`
-
-Using code blocks will make the content use monospaced font so that space will be aligned correctly
-
-IMPORTANT: add enough space characters to align the table! otherwise the content will not look good and will be difficult to understand for the user
-
-code blocks for tables and diagrams MUST have Max length of 85 characters. otherwise the content will wrap
 
 ## diagrams
 
-you can create diagrams wrapping them in code blocks too.
+you can create diagrams wrapping them in code blocks.
 `;
 }

package/dist/tools.js

@@ -1,3 +1,6 @@
+// Voice assistant tool definitions for the GenAI worker.
+// Provides tools for managing OpenCode sessions (create, submit, abort),
+// listing chats, searching files, and reading session messages.
 import { tool } from 'ai';
 import { z } from 'zod';
 import { spawn } from 'node:child_process';

package/dist/utils.js

@@ -1,3 +1,6 @@
+// General utility functions for the bot.
+// Includes Discord OAuth URL generation, array deduplication,
+// abort error detection, and date/time formatting helpers.
 import { PermissionsBitField } from 'discord.js';
 export function generateBotInstallUrl({ clientId, permissions = [
     PermissionsBitField.Flags.ViewChannel,

package/dist/voice-handler.js

@@ -1,3 +1,6 @@
+// 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 { VoiceConnectionStatus, EndBehaviorType, joinVoiceChannel, entersState, } from '@discordjs/voice';
 import { exec } from 'node:child_process';
 import fs, { createWriteStream } from 'node:fs';
@@ -311,7 +314,7 @@ export async function cleanupVoiceConnection(guildId) {
         voiceConnections.delete(guildId);
     }
 }
-export async function processVoiceAttachment({ message, thread, projectDirectory, isNewThread = false, appId, sessionMessages, }) {
+export async function processVoiceAttachment({ message, thread, projectDirectory, isNewThread = false, appId, currentSessionContext, lastSessionContext, }) {
     const audioAttachment = Array.from(message.attachments.values()).find((attachment) => attachment.contentType?.startsWith('audio/'));
     if (!audioAttachment)
         return null;
@@ -347,13 +350,23 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             geminiApiKey = apiKeys.gemini_api_key;
         }
     }
-    const transcription = await transcribeAudio({
-        audio: audioBuffer,
-        prompt: transcriptionPrompt,
-        geminiApiKey,
-        directory: projectDirectory,
-        sessionMessages,
-    });
+    let transcription;
+    try {
+        transcription = await transcribeAudio({
+            audio: audioBuffer,
+            prompt: transcriptionPrompt,
+            geminiApiKey,
+            directory: projectDirectory,
+            currentSessionContext,
+            lastSessionContext,
+        });
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        voiceLogger.error(`Transcription failed:`, error);
+        await sendThreadMessage(thread, `⚠️ Transcription failed: ${errMsg}`);
+        return null;
+    }
     voiceLogger.log(`Transcription successful: "${transcription.slice(0, 50)}${transcription.length > 50 ? '...' : ''}"`);
     if (isNewThread) {
         const threadName = transcription.replace(/\s+/g, ' ').trim().slice(0, 80);