kimaki 0.2.0 → 0.2.1

package/dist/discordBot.js

@@ -27,11 +27,8 @@ const dbLogger = createLogger('DB');
 const opencodeServers = new Map();
 // Map of session ID to current AbortController
 const abortControllers = new Map();
-// Map of guild ID to voice connection
+// Map of guild ID to voice connection and GenAI worker
 const voiceConnections = new Map();
-// Map of channel ID to GenAI worker and session state
-// This allows sessions to persist across voice channel changes
-const genAiSessions = new Map();
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map();
 let db = null;
@@ -82,7 +79,7 @@ async function createUserAudioLogStream(guildId, channelId) {
     }
 }
 // Set up voice handling for a connection (called once per connection)
-async function setupVoiceHandling({ connection, guildId, channelId, appId, cleanupGenAiSession, }) {
+async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
     voiceLogger.log(`Setting up voice handling for guild ${guildId}, channel ${channelId}`);
     // Check if this voice channel has an associated directory
     const channelDirRow = getDatabase()
@@ -102,28 +99,11 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, clean
     }
     // Create user audio stream for debugging
     voiceData.userAudioStream = await createUserAudioLogStream(guildId, channelId);
-    // Check if we already have a GenAI session for this channel
-    const existingSession = genAiSessions.get(channelId);
-    if (existingSession) {
-        voiceLogger.log(`Reusing existing GenAI session for channel ${channelId}`);
-        // Cancel any pending cleanup since user has returned
-        if (existingSession.pendingCleanup) {
-            voiceLogger.log(`Cancelling pending cleanup for channel ${channelId} - user returned`);
-            existingSession.pendingCleanup = false;
-            if (existingSession.cleanupTimer) {
-                clearTimeout(existingSession.cleanupTimer);
-                existingSession.cleanupTimer = undefined;
-            }
-        }
-        // Session already exists, just update the voice handling
-        return;
-    }
     // Get API keys from database
     const apiKeys = getDatabase()
         .prepare('SELECT gemini_api_key FROM bot_api_keys WHERE app_id = ?')
         .get(appId);
-    // Track if sessions are active
-    let hasActiveSessions = false;
+    // Create GenAI worker
     const genAiWorker = await createGenAIWorker({
         directory,
         guildId,
@@ -191,75 +171,28 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, clean
             genAiWorker.interrupt();
             connection.setSpeaking(false);
         },
-        onAllSessionsCompleted() {
-            // All OpenCode sessions have completed
-            hasActiveSessions = false;
-            voiceLogger.log('All OpenCode sessions completed for this GenAI session');
-            // Update the stored session state
-            const session = genAiSessions.get(channelId);
-            if (session) {
-                session.hasActiveSessions = false;
-                // If cleanup is pending (user left channel), schedule cleanup with grace period
-                if (session.pendingCleanup) {
-                    voiceLogger.log(`Scheduling cleanup for channel ${channelId} in 1 minute`);
-                    // Clear any existing timer
-                    if (session.cleanupTimer) {
-                        clearTimeout(session.cleanupTimer);
-                    }
-                    // Schedule cleanup after 1 minute grace period
-                    session.cleanupTimer = setTimeout(() => {
-                        // Double-check that cleanup is still needed
-                        const currentSession = genAiSessions.get(channelId);
-                        if (currentSession?.pendingCleanup &&
-                            !currentSession.hasActiveSessions) {
-                            voiceLogger.log(`Grace period expired, cleaning up GenAI session for channel ${channelId}`);
-                            // Use the main cleanup function - defined later in startDiscordBot
-                            cleanupGenAiSession(channelId);
-                        }
-                    }, 60000); // 1 minute
-                }
-            }
-        },
         onToolCallCompleted(params) {
-            // Note: We now track at the tools.ts level, but still handle completion messages
-            voiceLogger.log(`OpenCode session ${params.sessionId} completed`);
             const text = params.error
                 ? `<systemMessage>\nThe coding agent encountered an error while processing session ${params.sessionId}: ${params.error?.message || String(params.error)}\n</systemMessage>`
                 : `<systemMessage>\nThe coding agent finished working on session ${params.sessionId}\n\nHere's what the assistant wrote:\n${params.markdown}\n</systemMessage>`;
             genAiWorker.sendTextInput(text);
-            // Mark that we have active sessions (will be updated by onAllSessionsCompleted when done)
-            hasActiveSessions = true;
-            const session = genAiSessions.get(channelId);
-            if (session) {
-                session.hasActiveSessions = true;
-            }
         },
         onError(error) {
             voiceLogger.error('GenAI worker error:', error);
         },
     });
+    // Stop any existing GenAI worker before storing new one
+    if (voiceData.genAiWorker) {
+        voiceLogger.log('Stopping existing GenAI worker before creating new one');
+        await voiceData.genAiWorker.stop();
+    }
     // Send initial greeting
     genAiWorker.sendTextInput(`<systemMessage>\nsay "Hello boss, how we doing today?"\n</systemMessage>`);
-    // Store the GenAI session
-    genAiSessions.set(channelId, {
-        genAiWorker,
-        hasActiveSessions,
-        pendingCleanup: false,
-        cleanupTimer: undefined,
-        guildId,
-        channelId,
-        directory,
-    });
+    voiceData.genAiWorker = genAiWorker;
     // Set up voice receiver for user input
     const receiver = connection.receiver;
     // Remove all existing listeners to prevent accumulation
     receiver.speaking.removeAllListeners('start');
-    // Get the GenAI session for this channel
-    const genAiSession = genAiSessions.get(channelId);
-    if (!genAiSession) {
-        voiceLogger.error(`GenAI session was just created but not found for channel ${channelId}`);
-        return;
-    }
     // Counter to track overlapping speaking sessions
     let speakingSessionCount = 0;
     receiver.speaking.on('start', (userId) => {
@@ -306,16 +239,15 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, clean
                 // )
                 return;
             }
-            const genAiSession = genAiSessions.get(channelId);
-            if (!genAiSession) {
-                voiceLogger.warn(`[VOICE] Received audio frame but no GenAI session active for channel ${channelId}`);
+            if (!voiceData.genAiWorker) {
+                voiceLogger.warn(`[VOICE] Received audio frame but no GenAI worker active for guild ${guildId}`);
                 return;
             }
             // voiceLogger.debug('User audio chunk length', frame.length)
             // Write to PCM file if stream exists
             voiceData.userAudioStream?.write(frame);
             // stream incrementally — low latency
-            genAiSession.genAiWorker.sendRealtimeInput({
+            voiceData.genAiWorker.sendRealtimeInput({
                 audio: {
                     mimeType: 'audio/pcm;rate=16000',
                     data: frame.toString('base64'),
@@ -326,8 +258,7 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, clean
             // Only send audioStreamEnd if this is still the current session
             if (currentSessionCount === speakingSessionCount) {
                 voiceLogger.log(`User ${userId} stopped speaking (session ${currentSessionCount})`);
-                const genAiSession = genAiSessions.get(channelId);
-                genAiSession?.genAiWorker.sendRealtimeInput({
+                voiceData.genAiWorker?.sendRealtimeInput({
                     audioStreamEnd: true,
                 });
             }
@@ -718,17 +649,12 @@ export async function initializeOpencodeForDirectory(directory) {
         }
     });
     await waitForServer(port);
-    // Create a custom fetch that disables Bun's default timeout
-    const customFetch = (input, init) => {
-        return fetch(input, {
-            ...init,
-            // @ts-ignore - Bun-specific option to disable timeout
-            timeout: false,
-        });
-    };
     const client = createOpencodeClient({
         baseUrl: `http://localhost:${port}`,
-        fetch: customFetch,
+        fetch: (request) => fetch(request, {
+            // @ts-ignore
+            timeout: false,
+        }),
     });
     opencodeServers.set(directory, {
         process: serverProcess,
@@ -1737,37 +1663,19 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             voiceLogger.error('[INTERACTION] Error handling interaction:', error);
         }
     });
-    // Helper function to clean up GenAI session
-    async function cleanupGenAiSession(channelId) {
-        const genAiSession = genAiSessions.get(channelId);
-        if (!genAiSession)
-            return;
-        try {
-            // Clear any cleanup timer
-            if (genAiSession.cleanupTimer) {
-                clearTimeout(genAiSession.cleanupTimer);
-                genAiSession.cleanupTimer = undefined;
-            }
-            voiceLogger.log(`Stopping GenAI worker for channel ${channelId}...`);
-            await genAiSession.genAiWorker.stop();
-            voiceLogger.log(`GenAI worker stopped for channel ${channelId}`);
-            // Remove from map
-            genAiSessions.delete(channelId);
-            voiceLogger.log(`GenAI session cleanup complete for channel ${channelId}`);
-        }
-        catch (error) {
-            voiceLogger.error(`Error during GenAI session cleanup for channel ${channelId}:`, error);
-            // Still remove from map even if there was an error
-            genAiSessions.delete(channelId);
-        }
-    }
     // Helper function to clean up voice connection and associated resources
-    async function cleanupVoiceConnection(guildId, channelId) {
+    async function cleanupVoiceConnection(guildId) {
         const voiceData = voiceConnections.get(guildId);
         if (!voiceData)
             return;
         voiceLogger.log(`Starting cleanup for guild ${guildId}`);
         try {
+            // Stop GenAI worker if exists (this is async!)
+            if (voiceData.genAiWorker) {
+                voiceLogger.log(`Stopping GenAI worker...`);
+                await voiceData.genAiWorker.stop();
+                voiceLogger.log(`GenAI worker stopped`);
+            }
             // Close user audio stream if exists
             if (voiceData.userAudioStream) {
                 voiceLogger.log(`Closing user audio stream...`);
@@ -1787,33 +1695,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             // Remove from map
             voiceConnections.delete(guildId);
-            voiceLogger.log(`Voice connection cleanup complete for guild ${guildId}`);
-            // Mark the GenAI session for cleanup when all sessions complete
-            if (channelId) {
-                const genAiSession = genAiSessions.get(channelId);
-                if (genAiSession) {
-                    voiceLogger.log(`Marking channel ${channelId} for cleanup when sessions complete`);
-                    genAiSession.pendingCleanup = true;
-                    // If no active sessions, trigger cleanup immediately (with grace period)
-                    if (!genAiSession.hasActiveSessions) {
-                        voiceLogger.log(`No active sessions, scheduling cleanup for channel ${channelId} in 1 minute`);
-                        // Clear any existing timer
-                        if (genAiSession.cleanupTimer) {
-                            clearTimeout(genAiSession.cleanupTimer);
-                        }
-                        // Schedule cleanup after 1 minute grace period
-                        genAiSession.cleanupTimer = setTimeout(() => {
-                            // Double-check that cleanup is still needed
-                            const currentSession = genAiSessions.get(channelId);
-                            if (currentSession?.pendingCleanup &&
-                                !currentSession.hasActiveSessions) {
-                                voiceLogger.log(`Grace period expired, cleaning up GenAI session for channel ${channelId}`);
-                                cleanupGenAiSession(channelId);
-                            }
-                        }, 60000); // 1 minute
-                    }
-                }
-            }
+            voiceLogger.log(`Cleanup complete for guild ${guildId}`);
         }
         catch (error) {
             voiceLogger.error(`Error during cleanup for guild ${guildId}:`, error);
@@ -1856,7 +1738,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     if (!hasOtherAdmins) {
                         voiceLogger.log(`No other admins in channel, bot leaving voice channel in guild: ${guild.name}`);
                         // Properly clean up all resources
-                        await cleanupVoiceConnection(guildId, oldState.channelId);
+                        await cleanupVoiceConnection(guildId);
                     }
                     else {
                         voiceLogger.log(`Other admins still in channel, bot staying in voice channel`);
@@ -1892,15 +1774,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                                     selfDeaf: false,
                                     selfMute: false,
                                 });
-                                // Set up voice handling for the new channel
-                                // This will reuse existing GenAI session if one exists
-                                await setupVoiceHandling({
-                                    connection: voiceData.connection,
-                                    guildId,
-                                    channelId: voiceChannel.id,
-                                    appId: currentAppId,
-                                    cleanupGenAiSession,
-                                });
                             }
                         }
                         else {
@@ -1959,7 +1832,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     guildId: newState.guild.id,
                     channelId: voiceChannel.id,
                     appId: currentAppId,
-                    cleanupGenAiSession,
                 });
                 // Handle connection state changes
                 connection.on(VoiceConnectionStatus.Disconnected, async () => {
@@ -1982,7 +1854,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 connection.on(VoiceConnectionStatus.Destroyed, async () => {
                     voiceLogger.log(`Connection destroyed for guild: ${newState.guild.name}`);
                     // Use the cleanup function to ensure everything is properly closed
-                    await cleanupVoiceConnection(newState.guild.id, voiceChannel.id);
+                    await cleanupVoiceConnection(newState.guild.id);
                 });
                 // Handle errors
                 connection.on('error', (error) => {
@@ -1991,7 +1863,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             catch (error) {
                 voiceLogger.error(`Failed to join voice channel:`, error);
-                await cleanupVoiceConnection(newState.guild.id, voiceChannel.id);
+                await cleanupVoiceConnection(newState.guild.id);
             }
         }
         catch (error) {
@@ -2009,31 +1881,17 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
         ;
         global.shuttingDown = true;
         try {
-            // Clean up all voice connections
-            const voiceCleanupPromises = [];
-            for (const [guildId, voiceData] of voiceConnections) {
+            // Clean up all voice connections (this includes GenAI workers and audio streams)
+            const cleanupPromises = [];
+            for (const [guildId] of voiceConnections) {
                 voiceLogger.log(`[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`);
-                // Find the channel ID for this connection
-                const channelId = voiceData.connection.joinConfig.channelId || undefined;
-                voiceCleanupPromises.push(cleanupVoiceConnection(guildId, channelId));
-            }
-            // Wait for all voice cleanups to complete
-            if (voiceCleanupPromises.length > 0) {
-                voiceLogger.log(`[SHUTDOWN] Waiting for ${voiceCleanupPromises.length} voice connection(s) to clean up...`);
-                await Promise.allSettled(voiceCleanupPromises);
-                discordLogger.log(`All voice connections cleaned up`);
+                cleanupPromises.push(cleanupVoiceConnection(guildId));
             }
-            // Clean up all GenAI sessions (force cleanup regardless of active sessions)
-            const genAiCleanupPromises = [];
-            for (const [channelId, session] of genAiSessions) {
-                voiceLogger.log(`[SHUTDOWN] Cleaning up GenAI session for channel ${channelId} (active sessions: ${session.hasActiveSessions})`);
-                genAiCleanupPromises.push(cleanupGenAiSession(channelId));
-            }
-            // Wait for all GenAI cleanups to complete
-            if (genAiCleanupPromises.length > 0) {
-                voiceLogger.log(`[SHUTDOWN] Waiting for ${genAiCleanupPromises.length} GenAI session(s) to clean up...`);
-                await Promise.allSettled(genAiCleanupPromises);
-                discordLogger.log(`All GenAI sessions cleaned up`);
+            // Wait for all cleanups to complete
+            if (cleanupPromises.length > 0) {
+                voiceLogger.log(`[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`);
+                await Promise.allSettled(cleanupPromises);
+                discordLogger.log(`All voice connections cleaned up`);
             }
             // Kill all OpenCode servers
             for (const [dir, server] of opencodeServers) {

package/dist/genai-worker-wrapper.js

@@ -20,9 +20,6 @@ export function createGenAIWorker(options) {
                 case 'assistantInterruptSpeaking':
                     options.onAssistantInterruptSpeaking?.();
                     break;
-                case 'allSessionsCompleted':
-                    options.onAllSessionsCompleted?.();
-                    break;
                 case 'toolCallCompleted':
                     options.onToolCallCompleted?.(message);
                     break;

package/dist/genai-worker.js

@@ -205,11 +205,6 @@ parentPort.on('message', async (message) => {
                             ...params,
                         });
                     },
-                    onAllSessionsCompleted: () => {
-                        parentPort.postMessage({
-                            type: 'allSessionsCompleted',
-                        });
-                    },
                 });
                 // Start GenAI session
                 session = await startGenAiSession({

package/dist/tools.js

@@ -9,14 +9,12 @@ import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
 import { initializeOpencodeForDirectory } from './discordBot.js';
-export async function getTools({ onMessageCompleted, onAllSessionsCompleted, directory, }) {
+export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
     const markdownRenderer = new ShareMarkdown(client);
     const providersResponse = await client.config.providers({});
     const providers = providersResponse.data?.providers || [];
-    // Track all active OpenCode sessions
-    const activeSessions = new Set();
     // Helper: get last assistant model for a session (non-summary)
     const getSessionModel = async (sessionId) => {
         const res = await getClient().session.messages({ path: { id: sessionId } });
@@ -43,9 +41,6 @@ export async function getTools({ onMessageCompleted, onAllSessionsCompleted, dir
             }),
             execute: async ({ sessionId, message }) => {
                 const sessionModel = await getSessionModel(sessionId);
-                // Track this session as active
-                activeSessions.add(sessionId);
-                toolsLogger.log(`Session ${sessionId} started, ${activeSessions.size} active sessions`);
                 // do not await
                 getClient()
                     .session.prompt({
@@ -66,14 +61,6 @@ export async function getTools({ onMessageCompleted, onAllSessionsCompleted, dir
                         data: response.data,
                         markdown,
                     });
-                    // Remove from active sessions
-                    activeSessions.delete(sessionId);
-                    toolsLogger.log(`Session ${sessionId} completed, ${activeSessions.size} active sessions remaining`);
-                    // Check if all sessions are complete
-                    if (activeSessions.size === 0) {
-                        toolsLogger.log('All sessions completed');
-                        onAllSessionsCompleted?.();
-                    }
                 })
                     .catch((error) => {
                     onMessageCompleted?.({
@@ -81,14 +68,6 @@ export async function getTools({ onMessageCompleted, onAllSessionsCompleted, dir
                         messageId: '',
                         error,
                     });
-                    // Remove from active sessions even on error
-                    activeSessions.delete(sessionId);
-                    toolsLogger.log(`Session ${sessionId} failed, ${activeSessions.size} active sessions remaining`);
-                    // Check if all sessions are complete
-                    if (activeSessions.size === 0) {
-                        toolsLogger.log('All sessions completed');
-                        onAllSessionsCompleted?.();
-                    }
                 });
                 return {
                     success: true,
@@ -129,52 +108,32 @@ export async function getTools({ onMessageCompleted, onAllSessionsCompleted, dir
                     if (!session.data) {
                         throw new Error('Failed to create session');
                     }
-                    const newSessionId = session.data.id;
-                    // Track this session as active
-                    activeSessions.add(newSessionId);
-                    toolsLogger.log(`New session ${newSessionId} created, ${activeSessions.size} active sessions`);
                     // do not await
                     getClient()
                         .session.prompt({
-                        path: { id: newSessionId },
+                        path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
                         },
                     })
                         .then(async (response) => {
                         const markdown = await markdownRenderer.generate({
-                            sessionID: newSessionId,
+                            sessionID: session.data.id,
                             lastAssistantOnly: true,
                         });
                         onMessageCompleted?.({
-                            sessionId: newSessionId,
+                            sessionId: session.data.id,
                             messageId: '',
                             data: response.data,
                             markdown,
                         });
-                        // Remove from active sessions
-                        activeSessions.delete(newSessionId);
-                        toolsLogger.log(`Session ${newSessionId} completed, ${activeSessions.size} active sessions remaining`);
-                        // Check if all sessions are complete
-                        if (activeSessions.size === 0) {
-                            toolsLogger.log('All sessions completed');
-                            onAllSessionsCompleted?.();
-                        }
                     })
                         .catch((error) => {
                         onMessageCompleted?.({
-                            sessionId: newSessionId,
+                            sessionId: session.data.id,
                             messageId: '',
                             error,
                         });
-                        // Remove from active sessions even on error
-                        activeSessions.delete(newSessionId);
-                        toolsLogger.log(`Session ${newSessionId} failed, ${activeSessions.size} active sessions remaining`);
-                        // Check if all sessions are complete
-                        if (activeSessions.size === 0) {
-                            toolsLogger.log('All sessions completed');
-                            onAllSessionsCompleted?.();
-                        }
                     });
                     return {
                         success: true,

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [

package/src/discordBot.ts

@@ -70,30 +70,16 @@ const opencodeServers = new Map<
 // Map of session ID to current AbortController
 const abortControllers = new Map<string, AbortController>()
 
-// Map of guild ID to voice connection
+// Map of guild ID to voice connection and GenAI worker
 const voiceConnections = new Map<
   string,
   {
     connection: VoiceConnection
+    genAiWorker?: GenAIWorker
     userAudioStream?: fs.WriteStream
   }
 >()
 
-// Map of channel ID to GenAI worker and session state
-// This allows sessions to persist across voice channel changes
-const genAiSessions = new Map<
-  string,
-  {
-    genAiWorker: GenAIWorker
-    hasActiveSessions: boolean // Track if there are active OpenCode sessions
-    pendingCleanup: boolean // Track if cleanup was requested (user left channel)
-    cleanupTimer?: NodeJS.Timeout // Timer for delayed cleanup
-    guildId: string
-    channelId: string
-    directory: string
-  }
->()
-
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map<string, number>()
 
@@ -168,13 +154,11 @@ async function setupVoiceHandling({
   guildId,
   channelId,
   appId,
-  cleanupGenAiSession,
 }: {
   connection: VoiceConnection
   guildId: string
   channelId: string
   appId: string
-  cleanupGenAiSession: (channelId: string) => Promise<void>
 }) {
   voiceLogger.log(
     `Setting up voice handling for guild ${guildId}, channel ${channelId}`,
@@ -207,36 +191,12 @@ async function setupVoiceHandling({
   // Create user audio stream for debugging
   voiceData.userAudioStream = await createUserAudioLogStream(guildId, channelId)
 
-  // Check if we already have a GenAI session for this channel
-  const existingSession = genAiSessions.get(channelId)
-  if (existingSession) {
-    voiceLogger.log(`Reusing existing GenAI session for channel ${channelId}`)
-
-    // Cancel any pending cleanup since user has returned
-    if (existingSession.pendingCleanup) {
-      voiceLogger.log(
-        `Cancelling pending cleanup for channel ${channelId} - user returned`,
-      )
-      existingSession.pendingCleanup = false
-
-      if (existingSession.cleanupTimer) {
-        clearTimeout(existingSession.cleanupTimer)
-        existingSession.cleanupTimer = undefined
-      }
-    }
-
-    // Session already exists, just update the voice handling
-    return
-  }
-
   // Get API keys from database
   const apiKeys = getDatabase()
     .prepare('SELECT gemini_api_key FROM bot_api_keys WHERE app_id = ?')
     .get(appId) as { gemini_api_key: string | null } | undefined
 
-  // Track if sessions are active
-  let hasActiveSessions = false
-
+  // Create GenAI worker
   const genAiWorker = await createGenAIWorker({
     directory,
     guildId,
@@ -304,82 +264,30 @@ async function setupVoiceHandling({
       genAiWorker.interrupt()
       connection.setSpeaking(false)
     },
-    onAllSessionsCompleted() {
-      // All OpenCode sessions have completed
-      hasActiveSessions = false
-      voiceLogger.log('All OpenCode sessions completed for this GenAI session')
-
-      // Update the stored session state
-      const session = genAiSessions.get(channelId)
-      if (session) {
-        session.hasActiveSessions = false
-
-        // If cleanup is pending (user left channel), schedule cleanup with grace period
-        if (session.pendingCleanup) {
-          voiceLogger.log(
-            `Scheduling cleanup for channel ${channelId} in 1 minute`,
-          )
-
-          // Clear any existing timer
-          if (session.cleanupTimer) {
-            clearTimeout(session.cleanupTimer)
-          }
-
-          // Schedule cleanup after 1 minute grace period
-          session.cleanupTimer = setTimeout(() => {
-            // Double-check that cleanup is still needed
-            const currentSession = genAiSessions.get(channelId)
-            if (
-              currentSession?.pendingCleanup &&
-              !currentSession.hasActiveSessions
-            ) {
-              voiceLogger.log(
-                `Grace period expired, cleaning up GenAI session for channel ${channelId}`,
-              )
-              // Use the main cleanup function - defined later in startDiscordBot
-              cleanupGenAiSession(channelId)
-            }
-          }, 60000) // 1 minute
-        }
-      }
-    },
     onToolCallCompleted(params) {
-      // Note: We now track at the tools.ts level, but still handle completion messages
-      voiceLogger.log(`OpenCode session ${params.sessionId} completed`)
-
       const text = params.error
         ? `<systemMessage>\nThe coding agent encountered an error while processing session ${params.sessionId}: ${params.error?.message || String(params.error)}\n</systemMessage>`
         : `<systemMessage>\nThe coding agent finished working on session ${params.sessionId}\n\nHere's what the assistant wrote:\n${params.markdown}\n</systemMessage>`
 
       genAiWorker.sendTextInput(text)
-
-      // Mark that we have active sessions (will be updated by onAllSessionsCompleted when done)
-      hasActiveSessions = true
-      const session = genAiSessions.get(channelId)
-      if (session) {
-        session.hasActiveSessions = true
-      }
     },
     onError(error) {
       voiceLogger.error('GenAI worker error:', error)
     },
   })
 
+  // Stop any existing GenAI worker before storing new one
+  if (voiceData.genAiWorker) {
+    voiceLogger.log('Stopping existing GenAI worker before creating new one')
+    await voiceData.genAiWorker.stop()
+  }
+
   // Send initial greeting
   genAiWorker.sendTextInput(
     `<systemMessage>\nsay "Hello boss, how we doing today?"\n</systemMessage>`,
   )
 
-  // Store the GenAI session
-  genAiSessions.set(channelId, {
-    genAiWorker,
-    hasActiveSessions,
-    pendingCleanup: false,
-    cleanupTimer: undefined,
-    guildId,
-    channelId,
-    directory,
-  })
+  voiceData.genAiWorker = genAiWorker
 
   // Set up voice receiver for user input
   const receiver = connection.receiver
@@ -387,15 +295,6 @@ async function setupVoiceHandling({
   // Remove all existing listeners to prevent accumulation
   receiver.speaking.removeAllListeners('start')
 
-  // Get the GenAI session for this channel
-  const genAiSession = genAiSessions.get(channelId)
-  if (!genAiSession) {
-    voiceLogger.error(
-      `GenAI session was just created but not found for channel ${channelId}`,
-    )
-    return
-  }
-
   // Counter to track overlapping speaking sessions
   let speakingSessionCount = 0
 
@@ -451,10 +350,9 @@ async function setupVoiceHandling({
           return
         }
 
-        const genAiSession = genAiSessions.get(channelId)
-        if (!genAiSession) {
+        if (!voiceData.genAiWorker) {
           voiceLogger.warn(
-            `[VOICE] Received audio frame but no GenAI session active for channel ${channelId}`,
+            `[VOICE] Received audio frame but no GenAI worker active for guild ${guildId}`,
           )
           return
         }
@@ -464,7 +362,7 @@ async function setupVoiceHandling({
         voiceData.userAudioStream?.write(frame)
 
         // stream incrementally — low latency
-        genAiSession.genAiWorker.sendRealtimeInput({
+        voiceData.genAiWorker.sendRealtimeInput({
           audio: {
             mimeType: 'audio/pcm;rate=16000',
             data: frame.toString('base64'),
@@ -477,8 +375,7 @@ async function setupVoiceHandling({
           voiceLogger.log(
             `User ${userId} stopped speaking (session ${currentSessionCount})`,
           )
-          const genAiSession = genAiSessions.get(channelId)
-          genAiSession?.genAiWorker.sendRealtimeInput({
+          voiceData.genAiWorker?.sendRealtimeInput({
             audioStreamEnd: true,
           })
         } else {
@@ -982,21 +879,13 @@ export async function initializeOpencodeForDirectory(directory: string) {
 
   await waitForServer(port)
 
-  // Create a custom fetch that disables Bun's default timeout
-  const customFetch = (
-    input: string | URL | Request,
-    init?: RequestInit,
-  ): Promise<Response> => {
-    return fetch(input, {
-      ...init,
-      // @ts-ignore - Bun-specific option to disable timeout
-      timeout: false,
-    })
-  }
-
   const client = createOpencodeClient({
     baseUrl: `http://localhost:${port}`,
-    fetch: customFetch,
+    fetch: (request: Request) =>
+      fetch(request, {
+        // @ts-ignore
+        timeout: false,
+      }),
   })
 
   opencodeServers.set(directory, {
@@ -2345,43 +2234,21 @@ export async function startDiscordBot({
     },
   )
 
-  // Helper function to clean up GenAI session
-  async function cleanupGenAiSession(channelId: string) {
-    const genAiSession = genAiSessions.get(channelId)
-    if (!genAiSession) return
-
-    try {
-      // Clear any cleanup timer
-      if (genAiSession.cleanupTimer) {
-        clearTimeout(genAiSession.cleanupTimer)
-        genAiSession.cleanupTimer = undefined
-      }
-
-      voiceLogger.log(`Stopping GenAI worker for channel ${channelId}...`)
-      await genAiSession.genAiWorker.stop()
-      voiceLogger.log(`GenAI worker stopped for channel ${channelId}`)
-
-      // Remove from map
-      genAiSessions.delete(channelId)
-      voiceLogger.log(`GenAI session cleanup complete for channel ${channelId}`)
-    } catch (error) {
-      voiceLogger.error(
-        `Error during GenAI session cleanup for channel ${channelId}:`,
-        error,
-      )
-      // Still remove from map even if there was an error
-      genAiSessions.delete(channelId)
-    }
-  }
-
   // Helper function to clean up voice connection and associated resources
-  async function cleanupVoiceConnection(guildId: string, channelId?: string) {
+  async function cleanupVoiceConnection(guildId: string) {
     const voiceData = voiceConnections.get(guildId)
     if (!voiceData) return
 
     voiceLogger.log(`Starting cleanup for guild ${guildId}`)
 
     try {
+      // Stop GenAI worker if exists (this is async!)
+      if (voiceData.genAiWorker) {
+        voiceLogger.log(`Stopping GenAI worker...`)
+        await voiceData.genAiWorker.stop()
+        voiceLogger.log(`GenAI worker stopped`)
+      }
+
       // Close user audio stream if exists
       if (voiceData.userAudioStream) {
         voiceLogger.log(`Closing user audio stream...`)
@@ -2405,45 +2272,7 @@ export async function startDiscordBot({
 
       // Remove from map
       voiceConnections.delete(guildId)
-      voiceLogger.log(`Voice connection cleanup complete for guild ${guildId}`)
-
-      // Mark the GenAI session for cleanup when all sessions complete
-      if (channelId) {
-        const genAiSession = genAiSessions.get(channelId)
-        if (genAiSession) {
-          voiceLogger.log(
-            `Marking channel ${channelId} for cleanup when sessions complete`,
-          )
-          genAiSession.pendingCleanup = true
-
-          // If no active sessions, trigger cleanup immediately (with grace period)
-          if (!genAiSession.hasActiveSessions) {
-            voiceLogger.log(
-              `No active sessions, scheduling cleanup for channel ${channelId} in 1 minute`,
-            )
-
-            // Clear any existing timer
-            if (genAiSession.cleanupTimer) {
-              clearTimeout(genAiSession.cleanupTimer)
-            }
-
-            // Schedule cleanup after 1 minute grace period
-            genAiSession.cleanupTimer = setTimeout(() => {
-              // Double-check that cleanup is still needed
-              const currentSession = genAiSessions.get(channelId)
-              if (
-                currentSession?.pendingCleanup &&
-                !currentSession.hasActiveSessions
-              ) {
-                voiceLogger.log(
-                  `Grace period expired, cleaning up GenAI session for channel ${channelId}`,
-                )
-                cleanupGenAiSession(channelId)
-              }
-            }, 60000) // 1 minute
-          }
-        }
-      }
+      voiceLogger.log(`Cleanup complete for guild ${guildId}`)
     } catch (error) {
       voiceLogger.error(`Error during cleanup for guild ${guildId}:`, error)
       // Still remove from map even if there was an error
@@ -2501,7 +2330,7 @@ export async function startDiscordBot({
             )
 
             // Properly clean up all resources
-            await cleanupVoiceConnection(guildId, oldState.channelId)
+            await cleanupVoiceConnection(guildId)
           } else {
             voiceLogger.log(
               `Other admins still in channel, bot staying in voice channel`,
@@ -2551,16 +2380,6 @@ export async function startDiscordBot({
                   selfDeaf: false,
                   selfMute: false,
                 })
-
-                // Set up voice handling for the new channel
-                // This will reuse existing GenAI session if one exists
-                await setupVoiceHandling({
-                  connection: voiceData.connection,
-                  guildId,
-                  channelId: voiceChannel.id,
-                  appId: currentAppId!,
-                  cleanupGenAiSession,
-                })
               }
             } else {
               voiceLogger.log(
@@ -2643,7 +2462,6 @@ export async function startDiscordBot({
           guildId: newState.guild.id,
           channelId: voiceChannel.id,
           appId: currentAppId!,
-          cleanupGenAiSession,
         })
 
         // Handle connection state changes
@@ -2671,7 +2489,7 @@ export async function startDiscordBot({
             `Connection destroyed for guild: ${newState.guild.name}`,
           )
           // Use the cleanup function to ensure everything is properly closed
-          await cleanupVoiceConnection(newState.guild.id, voiceChannel.id)
+          await cleanupVoiceConnection(newState.guild.id)
         })
 
         // Handle errors
@@ -2683,7 +2501,7 @@ export async function startDiscordBot({
         })
       } catch (error) {
         voiceLogger.error(`Failed to join voice channel:`, error)
-        await cleanupVoiceConnection(newState.guild.id, voiceChannel.id)
+        await cleanupVoiceConnection(newState.guild.id)
       }
     } catch (error) {
       voiceLogger.error('Error in voice state update handler:', error)
@@ -2703,44 +2521,24 @@ export async function startDiscordBot({
     ;(global as any).shuttingDown = true
 
     try {
-      // Clean up all voice connections
-      const voiceCleanupPromises: Promise<void>[] = []
-      for (const [guildId, voiceData] of voiceConnections) {
+      // Clean up all voice connections (this includes GenAI workers and audio streams)
+      const cleanupPromises: Promise<void>[] = []
+      for (const [guildId] of voiceConnections) {
         voiceLogger.log(
           `[SHUTDOWN] Cleaning up voice connection for guild ${guildId}`,
         )
-        // Find the channel ID for this connection
-        const channelId = voiceData.connection.joinConfig.channelId || undefined
-        voiceCleanupPromises.push(cleanupVoiceConnection(guildId, channelId))
+        cleanupPromises.push(cleanupVoiceConnection(guildId))
       }
 
-      // Wait for all voice cleanups to complete
-      if (voiceCleanupPromises.length > 0) {
+      // Wait for all cleanups to complete
+      if (cleanupPromises.length > 0) {
         voiceLogger.log(
-          `[SHUTDOWN] Waiting for ${voiceCleanupPromises.length} voice connection(s) to clean up...`,
+          `[SHUTDOWN] Waiting for ${cleanupPromises.length} voice connection(s) to clean up...`,
         )
-        await Promise.allSettled(voiceCleanupPromises)
+        await Promise.allSettled(cleanupPromises)
         discordLogger.log(`All voice connections cleaned up`)
       }
 
-      // Clean up all GenAI sessions (force cleanup regardless of active sessions)
-      const genAiCleanupPromises: Promise<void>[] = []
-      for (const [channelId, session] of genAiSessions) {
-        voiceLogger.log(
-          `[SHUTDOWN] Cleaning up GenAI session for channel ${channelId} (active sessions: ${session.hasActiveSessions})`,
-        )
-        genAiCleanupPromises.push(cleanupGenAiSession(channelId))
-      }
-
-      // Wait for all GenAI cleanups to complete
-      if (genAiCleanupPromises.length > 0) {
-        voiceLogger.log(
-          `[SHUTDOWN] Waiting for ${genAiCleanupPromises.length} GenAI session(s) to clean up...`,
-        )
-        await Promise.allSettled(genAiCleanupPromises)
-        discordLogger.log(`All GenAI sessions cleaned up`)
-      }
-
       // Kill all OpenCode servers
       for (const [dir, server] of opencodeServers) {
         if (!server.process.killed) {

package/src/genai-worker-wrapper.ts

@@ -17,7 +17,6 @@ export interface GenAIWorkerOptions {
   onAssistantStartSpeaking?: () => void
   onAssistantStopSpeaking?: () => void
   onAssistantInterruptSpeaking?: () => void
-  onAllSessionsCompleted?: () => void
   onToolCallCompleted?: (params: {
     sessionId: string
     messageId: string
@@ -61,9 +60,6 @@ export function createGenAIWorker(
         case 'assistantInterruptSpeaking':
           options.onAssistantInterruptSpeaking?.()
           break
-        case 'allSessionsCompleted':
-          options.onAllSessionsCompleted?.()
-          break
         case 'toolCallCompleted':
           options.onToolCallCompleted?.(message)
           break

package/src/genai-worker.ts

@@ -265,11 +265,6 @@ parentPort.on('message', async (message: WorkerInMessage) => {
               ...params,
             } satisfies WorkerOutMessage)
           },
-          onAllSessionsCompleted: () => {
-            parentPort!.postMessage({
-              type: 'allSessionsCompleted',
-            } satisfies WorkerOutMessage)
-          },
         })
 
         // Start GenAI session

package/src/tools.ts

@@ -19,7 +19,6 @@ import { initializeOpencodeForDirectory } from './discordBot.js'
 
 export async function getTools({
   onMessageCompleted,
-  onAllSessionsCompleted,
   directory,
 }: {
   directory: string
@@ -30,7 +29,6 @@ export async function getTools({
     error?: unknown
     markdown?: string
   }) => void
-  onAllSessionsCompleted?: () => void
 }) {
   const getClient = await initializeOpencodeForDirectory(directory)
   const client = getClient()
@@ -39,9 +37,6 @@ export async function getTools({
 
   const providersResponse = await client.config.providers({})
   const providers: Provider[] = providersResponse.data?.providers || []
-  
-  // Track all active OpenCode sessions
-  const activeSessions = new Set<string>()
 
   // Helper: get last assistant model for a session (non-summary)
   const getSessionModel = async (
@@ -73,10 +68,6 @@ export async function getTools({
       execute: async ({ sessionId, message }) => {
         const sessionModel = await getSessionModel(sessionId)
 
-        // Track this session as active
-        activeSessions.add(sessionId)
-        toolsLogger.log(`Session ${sessionId} started, ${activeSessions.size} active sessions`)
-
         // do not await
         getClient()
           .session.prompt({
@@ -98,16 +89,6 @@ export async function getTools({
               data: response.data,
               markdown,
             })
-            
-            // Remove from active sessions
-            activeSessions.delete(sessionId)
-            toolsLogger.log(`Session ${sessionId} completed, ${activeSessions.size} active sessions remaining`)
-            
-            // Check if all sessions are complete
-            if (activeSessions.size === 0) {
-              toolsLogger.log('All sessions completed')
-              onAllSessionsCompleted?.()
-            }
           })
           .catch((error) => {
             onMessageCompleted?.({
@@ -115,16 +96,6 @@ export async function getTools({
               messageId: '',
               error,
             })
-            
-            // Remove from active sessions even on error
-            activeSessions.delete(sessionId)
-            toolsLogger.log(`Session ${sessionId} failed, ${activeSessions.size} active sessions remaining`)
-            
-            // Check if all sessions are complete
-            if (activeSessions.size === 0) {
-              toolsLogger.log('All sessions completed')
-              onAllSessionsCompleted?.()
-            }
           })
         return {
           success: true,
@@ -172,58 +143,32 @@ export async function getTools({
             throw new Error('Failed to create session')
           }
 
-          const newSessionId = session.data.id
-          
-          // Track this session as active
-          activeSessions.add(newSessionId)
-          toolsLogger.log(`New session ${newSessionId} created, ${activeSessions.size} active sessions`)
-
           // do not await
           getClient()
             .session.prompt({
-              path: { id: newSessionId },
+              path: { id: session.data.id },
               body: {
                 parts: [{ type: 'text', text: message }],
               },
             })
             .then(async (response) => {
               const markdown = await markdownRenderer.generate({
-                sessionID: newSessionId,
+                sessionID: session.data.id,
                 lastAssistantOnly: true,
               })
               onMessageCompleted?.({
-                sessionId: newSessionId,
+                sessionId: session.data.id,
                 messageId: '',
                 data: response.data,
                 markdown,
               })
-              
-              // Remove from active sessions
-              activeSessions.delete(newSessionId)
-              toolsLogger.log(`Session ${newSessionId} completed, ${activeSessions.size} active sessions remaining`)
-              
-              // Check if all sessions are complete
-              if (activeSessions.size === 0) {
-                toolsLogger.log('All sessions completed')
-                onAllSessionsCompleted?.()
-              }
             })
             .catch((error) => {
               onMessageCompleted?.({
-                sessionId: newSessionId,
+                sessionId: session.data.id,
                 messageId: '',
                 error,
               })
-              
-              // Remove from active sessions even on error
-              activeSessions.delete(newSessionId)
-              toolsLogger.log(`Session ${newSessionId} failed, ${activeSessions.size} active sessions remaining`)
-              
-              // Check if all sessions are complete
-              if (activeSessions.size === 0) {
-                toolsLogger.log('All sessions completed')
-                onAllSessionsCompleted?.()
-              }
             })
 
           return {

package/src/worker-types.ts

@@ -53,9 +53,6 @@ export type WorkerOutMessage =
       error?: any
       markdown?: string
     }
-  | {
-      type: 'allSessionsCompleted'
-    }
   | {
       type: 'error'
       error: string