kimaki 0.4.18 → 0.4.20

package/dist/discordBot.js

@@ -39,6 +39,8 @@ export function getOpencodeSystemMessage({ sessionId }) {
     return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
+The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
+
 Your current OpenCode session ID is: ${sessionId}
 
 ## uploading files to discord
@@ -458,6 +460,7 @@ export function getDatabase() {
       CREATE TABLE IF NOT EXISTS bot_api_keys (
         app_id TEXT PRIMARY KEY,
         gemini_api_key TEXT,
+        xai_api_key TEXT,
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
     `);
@@ -642,11 +645,50 @@ async function processVoiceAttachment({ message, thread, projectDirectory, isNew
     await sendThreadMessage(thread, `📝 **Transcribed message:** ${escapeDiscordFormatting(transcription)}`);
     return transcription;
 }
-function getImageAttachments(message) {
-    const imageAttachments = Array.from(message.attachments.values()).filter((attachment) => attachment.contentType?.startsWith('image/'));
-    return imageAttachments.map((attachment) => ({
+const TEXT_MIME_TYPES = [
+    'text/',
+    'application/json',
+    'application/xml',
+    'application/javascript',
+    'application/typescript',
+    'application/x-yaml',
+    'application/toml',
+];
+function isTextMimeType(contentType) {
+    if (!contentType) {
+        return false;
+    }
+    return TEXT_MIME_TYPES.some((prefix) => contentType.startsWith(prefix));
+}
+async function getTextAttachments(message) {
+    const textAttachments = Array.from(message.attachments.values()).filter((attachment) => isTextMimeType(attachment.contentType));
+    if (textAttachments.length === 0) {
+        return '';
+    }
+    const textContents = await Promise.all(textAttachments.map(async (attachment) => {
+        try {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                return `<attachment filename="${attachment.name}" error="Failed to fetch: ${response.status}" />`;
+            }
+            const text = await response.text();
+            return `<attachment filename="${attachment.name}" mime="${attachment.contentType}">\n${text}\n</attachment>`;
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return `<attachment filename="${attachment.name}" error="${errMsg}" />`;
+        }
+    }));
+    return textContents.join('\n\n');
+}
+function getFileAttachments(message) {
+    const fileAttachments = Array.from(message.attachments.values()).filter((attachment) => {
+        const contentType = attachment.contentType || '';
+        return (contentType.startsWith('image/') || contentType === 'application/pdf');
+    });
+    return fileAttachments.map((attachment) => ({
         type: 'file',
-        mime: attachment.contentType || 'image/png',
+        mime: attachment.contentType || 'application/octet-stream',
         filename: attachment.name,
         url: attachment.url,
     }));
@@ -897,13 +939,6 @@ export async function initializeOpencodeForDirectory(directory) {
 function getToolSummaryText(part) {
     if (part.type !== 'tool')
         return '';
-    if (part.state.status !== 'completed' && part.state.status !== 'error')
-        return '';
-    if (part.tool === 'bash') {
-        const output = part.state.status === 'completed' ? part.state.output : part.state.error;
-        const lines = (output || '').split('\n').filter((l) => l.trim());
-        return `(${lines.length} line${lines.length === 1 ? '' : 's'})`;
-    }
     if (part.tool === 'edit') {
         const newString = part.state.input?.newString || '';
         const oldString = part.state.input?.oldString || '';
@@ -921,7 +956,8 @@ function getToolSummaryText(part) {
         const urlWithoutProtocol = url.replace(/^https?:\/\//, '');
         return urlWithoutProtocol ? `(${urlWithoutProtocol})` : '';
     }
-    if (part.tool === 'read' ||
+    if (part.tool === 'bash' ||
+        part.tool === 'read' ||
         part.tool === 'list' ||
         part.tool === 'glob' ||
         part.tool === 'grep' ||
@@ -937,7 +973,7 @@ function getToolSummaryText(part) {
         if (value === null || value === undefined)
             return null;
         const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-        const truncatedValue = stringValue.length > 100 ? stringValue.slice(0, 100) + '…' : stringValue;
+        const truncatedValue = stringValue.length > 300 ? stringValue.slice(0, 300) + '…' : stringValue;
         return `${key}: ${truncatedValue}`;
     })
         .filter(Boolean);
@@ -945,16 +981,6 @@ function getToolSummaryText(part) {
         return '';
     return `(${inputFields.join(', ')})`;
 }
-function getToolOutputToDisplay(part) {
-    if (part.type !== 'tool')
-        return '';
-    if (part.state.status !== 'completed' && part.state.status !== 'error')
-        return '';
-    if (part.state.status === 'error') {
-        return part.state.error || 'Unknown error';
-    }
-    return '';
-}
 function formatTodoList(part) {
     if (part.type !== 'tool' || part.tool !== 'todowrite')
         return '';
@@ -999,35 +1025,36 @@ function formatPart(part) {
         if (part.tool === 'todowrite') {
             return formatTodoList(part);
         }
-        if (part.state.status !== 'completed' && part.state.status !== 'error') {
+        if (part.state.status === 'pending') {
             return '';
         }
         const summaryText = getToolSummaryText(part);
-        const outputToDisplay = getToolOutputToDisplay(part);
+        const stateTitle = 'title' in part.state ? part.state.title : undefined;
         let toolTitle = '';
         if (part.state.status === 'error') {
-            toolTitle = 'error';
+            toolTitle = part.state.error || 'error';
         }
         else if (part.tool === 'bash') {
             const command = part.state.input?.command || '';
             const isSingleLine = !command.includes('\n');
             const hasBackticks = command.includes('`');
             if (isSingleLine && command.length <= 120 && !hasBackticks) {
-                toolTitle = `\`${command}\``;
+                toolTitle = `_${command}_`;
             }
             else {
-                toolTitle = part.state.title ? `*${part.state.title}*` : '';
+                toolTitle = stateTitle ? `_${stateTitle}_` : '';
             }
         }
-        else if (part.state.title) {
-            toolTitle = `*${part.state.title}*`;
+        else if (part.tool === 'edit' || part.tool === 'write') {
+            const filePath = part.state.input?.filePath || '';
+            const fileName = filePath.split('/').pop() || filePath;
+            toolTitle = fileName ? `_${fileName}_` : '';
         }
-        const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : '';
-        const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
-        if (outputToDisplay) {
-            return title + '\n\n' + outputToDisplay;
+        else if (stateTitle) {
+            toolTitle = `_${stateTitle}_`;
         }
-        return title;
+        const icon = part.state.status === 'error' ? '⨯' : '◼︎';
+        return `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
     }
     discordLogger.warn('Unknown part type:', part);
     return '';
@@ -1052,16 +1079,6 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     // Track session start time
     const sessionStartTime = Date.now();
-    // Add processing reaction to original message
-    if (originalMessage) {
-        try {
-            await originalMessage.react('⏳');
-            discordLogger.log(`Added processing reaction to message`);
-        }
-        catch (e) {
-            discordLogger.log(`Could not add processing reaction:`, e);
-        }
-    }
     // Use default directory if not specified
     const directory = projectDirectory || process.cwd();
     sessionLogger.log(`Using directory: ${directory}`);
@@ -1090,9 +1107,10 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
     }
     if (!session) {
-        voiceLogger.log(`[SESSION] Creating new session with title: "${prompt.slice(0, 80)}"`);
+        const sessionTitle = prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt.slice(0, 80);
+        voiceLogger.log(`[SESSION] Creating new session with title: "${sessionTitle}"`);
         const sessionResponse = await getClient().session.create({
-            body: { title: prompt.slice(0, 80) },
+            body: { title: sessionTitle },
         });
         session = sessionResponse.data;
         sessionLogger.log(`Created new session ${session?.id}`);
@@ -1111,39 +1129,37 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         voiceLogger.log(`[ABORT] Cancelling existing request for session: ${session.id}`);
         existingController.abort(new Error('New request started'));
     }
-    if (abortControllers.has(session.id)) {
-        abortControllers.get(session.id)?.abort(new Error('new reply'));
-    }
     const abortController = new AbortController();
-    // Store this controller for this session
     abortControllers.set(session.id, abortController);
+    if (existingController) {
+        await new Promise((resolve) => { setTimeout(resolve, 200); });
+        if (abortController.signal.aborted) {
+            sessionLogger.log(`[DEBOUNCE] Request was superseded during wait, exiting`);
+            return;
+        }
+    }
+    if (abortController.signal.aborted) {
+        sessionLogger.log(`[DEBOUNCE] Aborted before subscribe, exiting`);
+        return;
+    }
     const eventsResult = await getClient().event.subscribe({
         signal: abortController.signal,
     });
+    if (abortController.signal.aborted) {
+        sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`);
+        return;
+    }
     const events = eventsResult.stream;
     sessionLogger.log(`Subscribed to OpenCode events`);
-    // Load existing part-message mappings from database
-    const partIdToMessage = new Map();
-    const existingParts = getDatabase()
-        .prepare('SELECT part_id, message_id FROM part_messages WHERE thread_id = ?')
-        .all(thread.id);
-    // Pre-populate map with existing messages
-    for (const row of existingParts) {
-        try {
-            const message = await thread.messages.fetch(row.message_id);
-            if (message) {
-                partIdToMessage.set(row.part_id, message);
-            }
-        }
-        catch (error) {
-            voiceLogger.log(`Could not fetch message ${row.message_id} for part ${row.part_id}`);
-        }
-    }
+    const sentPartIds = new Set(getDatabase()
+        .prepare('SELECT part_id FROM part_messages WHERE thread_id = ?')
+        .all(thread.id)
+        .map((row) => row.part_id));
     let currentParts = [];
     let stopTyping = null;
     let usedModel;
     let usedProviderID;
-    let inputTokens = 0;
+    let tokensUsedInSession = 0;
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -1151,12 +1167,12 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
             return;
         }
         // Skip if already sent
-        if (partIdToMessage.has(part.id)) {
+        if (sentPartIds.has(part.id)) {
             return;
         }
         try {
             const firstMessage = await sendThreadMessage(thread, content);
-            partIdToMessage.set(part.id, firstMessage);
+            sentPartIds.add(part.id);
             // Store part-message mapping in database
             getDatabase()
                 .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
@@ -1219,12 +1235,13 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     }
                     // Track assistant message ID
                     if (msg.role === 'assistant') {
+                        const newTokensTotal = msg.tokens.input + msg.tokens.output + msg.tokens.reasoning + msg.tokens.cache.read + msg.tokens.cache.write;
+                        if (newTokensTotal > 0) {
+                            tokensUsedInSession = newTokensTotal;
+                        }
                         assistantMessageId = msg.id;
                         usedModel = msg.modelID;
                         usedProviderID = msg.providerID;
-                        if (msg.tokens.input > 0) {
-                            inputTokens = msg.tokens.input;
-                        }
                     }
                 }
                 else if (event.type === 'message.part.updated') {
@@ -1247,13 +1264,16 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     if (part.type === 'step-start') {
                         stopTyping = startTyping(thread);
                     }
+                    // Send tool parts immediately when they start running
+                    if (part.type === 'tool' && part.state.status === 'running') {
+                        await sendPartMessage(part);
+                    }
+                    // Send reasoning parts immediately (shows "◼︎ thinking" indicator early)
+                    if (part.type === 'reasoning') {
+                        await sendPartMessage(part);
+                    }
                     // Check if this is a step-finish part
                     if (part.type === 'step-finish') {
-                        // Track tokens from step-finish part
-                        if (part.tokens?.input && part.tokens.input > 0) {
-                            inputTokens = part.tokens.input;
-                            voiceLogger.log(`[STEP-FINISH] Captured tokens: ${inputTokens}`);
-                        }
                         // Send all parts accumulated so far to Discord
                         for (const p of currentParts) {
                             // Skip step-start and step-finish parts as they have no visual content
@@ -1338,7 +1358,7 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         finally {
             // Send any remaining parts that weren't sent
             for (const part of currentParts) {
-                if (!partIdToMessage.has(part.id)) {
+                if (!sentPartIds.has(part.id)) {
                     try {
                         await sendPartMessage(part);
                     }
@@ -1359,22 +1379,20 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
                 let contextInfo = '';
-                if (inputTokens > 0 && usedProviderID && usedModel) {
-                    try {
-                        const providersResponse = await getClient().provider.list({ query: { directory } });
-                        const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
-                        const model = provider?.models?.[usedModel];
-                        if (model?.limit?.context) {
-                            const percentage = Math.round((inputTokens / model.limit.context) * 100);
-                            contextInfo = ` ⋅ ${percentage}%`;
-                        }
-                    }
-                    catch (e) {
-                        sessionLogger.error('Failed to fetch provider info for context percentage:', e);
+                try {
+                    const providersResponse = await getClient().provider.list({ query: { directory } });
+                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                    const model = provider?.models?.[usedModel || ''];
+                    if (model?.limit?.context) {
+                        const percentage = Math.round((tokensUsedInSession / model.limit.context) * 100);
+                        contextInfo = ` ⋅ ${percentage}%`;
                     }
                 }
+                catch (e) {
+                    sessionLogger.error('Failed to fetch provider info for context percentage:', e);
+                }
                 await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`);
-                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${inputTokens}`);
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
             }
             else {
                 sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
@@ -1382,8 +1400,19 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
     };
     try {
-        // Start the event handler
         const eventHandlerPromise = eventHandler();
+        if (abortController.signal.aborted) {
+            sessionLogger.log(`[DEBOUNCE] Aborted before prompt, exiting`);
+            return;
+        }
+        if (originalMessage) {
+            try {
+                await originalMessage.react('⏳');
+            }
+            catch (e) {
+                discordLogger.log(`Could not add processing reaction:`, e);
+            }
+        }
         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 ? '...' : ''}"`);
@@ -1412,17 +1441,30 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 signal: abortController.signal,
             });
         }
+        if (response.error) {
+            const errorMessage = (() => {
+                const err = response.error;
+                if (err && typeof err === 'object') {
+                    if ('data' in err && err.data && typeof err.data === 'object' && 'message' in err.data) {
+                        return String(err.data.message);
+                    }
+                    if ('errors' in err && Array.isArray(err.errors) && err.errors.length > 0) {
+                        return JSON.stringify(err.errors);
+                    }
+                }
+                return JSON.stringify(err);
+            })();
+            throw new Error(`OpenCode API error (${response.response.status}): ${errorMessage}`);
+        }
         abortController.abort('finished');
         sessionLogger.log(`Successfully sent prompt, got response`);
-        // Update reaction to success
         if (originalMessage) {
             try {
                 await originalMessage.reactions.removeAll();
                 await originalMessage.react('✅');
-                discordLogger.log(`Added success reaction to message`);
             }
             catch (e) {
-                discordLogger.log(`Could not update reaction:`, e);
+                discordLogger.log(`Could not update reactions:`, e);
             }
         }
         return { sessionID: session.id, result: response.data, port };
@@ -1596,14 +1638,18 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                const images = getImageAttachments(message);
+                const fileAttachments = getFileAttachments(message);
+                const textAttachmentsContent = await getTextAttachments(message);
+                const promptWithAttachments = textAttachmentsContent
+                    ? `${messageContent}\n\n${textAttachmentsContent}`
+                    : messageContent;
                 const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
-                    prompt: messageContent,
+                    prompt: promptWithAttachments,
                     thread,
                     projectDirectory,
                     originalMessage: message,
-                    images,
+                    images: fileAttachments,
                     parsedCommand,
                 });
                 return;
@@ -1664,14 +1710,18 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                const images = getImageAttachments(message);
+                const fileAttachments = getFileAttachments(message);
+                const textAttachmentsContent = await getTextAttachments(message);
+                const promptWithAttachments = textAttachmentsContent
+                    ? `${messageContent}\n\n${textAttachmentsContent}`
+                    : messageContent;
                 const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
-                    prompt: messageContent,
+                    prompt: promptWithAttachments,
                     thread,
                     projectDirectory,
                     originalMessage: message,
-                    images,
+                    images: fileAttachments,
                     parsedCommand,
                 });
             }
@@ -2093,6 +2143,72 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     }
                 }
+                else if (command.commandName === 'add-new-project') {
+                    await command.deferReply({ ephemeral: false });
+                    const projectName = command.options.getString('name', true);
+                    const guild = command.guild;
+                    const channel = command.channel;
+                    if (!guild) {
+                        await command.editReply('This command can only be used in a guild');
+                        return;
+                    }
+                    if (!channel || channel.type !== ChannelType.GuildText) {
+                        await command.editReply('This command can only be used in a text channel');
+                        return;
+                    }
+                    const sanitizedName = projectName
+                        .toLowerCase()
+                        .replace(/[^a-z0-9-]/g, '-')
+                        .replace(/-+/g, '-')
+                        .replace(/^-|-$/g, '')
+                        .slice(0, 100);
+                    if (!sanitizedName) {
+                        await command.editReply('Invalid project name');
+                        return;
+                    }
+                    const kimakiDir = path.join(os.homedir(), 'kimaki');
+                    const projectDirectory = path.join(kimakiDir, sanitizedName);
+                    try {
+                        if (!fs.existsSync(kimakiDir)) {
+                            fs.mkdirSync(kimakiDir, { recursive: true });
+                            discordLogger.log(`Created kimaki directory: ${kimakiDir}`);
+                        }
+                        if (fs.existsSync(projectDirectory)) {
+                            await command.editReply(`Project directory already exists: ${projectDirectory}`);
+                            return;
+                        }
+                        fs.mkdirSync(projectDirectory, { recursive: true });
+                        discordLogger.log(`Created project directory: ${projectDirectory}`);
+                        const { execSync } = await import('node:child_process');
+                        execSync('git init', { cwd: projectDirectory, stdio: 'pipe' });
+                        discordLogger.log(`Initialized git in: ${projectDirectory}`);
+                        const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
+                            guild,
+                            projectDirectory,
+                            appId: currentAppId,
+                        });
+                        const textChannel = await guild.channels.fetch(textChannelId);
+                        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n\n_Starting session..._`);
+                        const starterMessage = await textChannel.send({
+                            content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
+                        });
+                        const thread = await starterMessage.startThread({
+                            name: `Init: ${sanitizedName}`,
+                            autoArchiveDuration: 1440,
+                            reason: 'New project session',
+                        });
+                        await handleOpencodeSession({
+                            prompt: 'The project was just initialized. Say hi and ask what the user wants to build.',
+                            thread,
+                            projectDirectory,
+                        });
+                        discordLogger.log(`Created new project ${channelName} at ${projectDirectory}`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ADD-NEW-PROJECT] Error:', error);
+                        await command.editReply(`Failed to create new project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
                 else if (command.commandName === 'accept' ||
                     command.commandName === 'accept-always') {
                     const scope = command.commandName === 'accept-always' ? 'always' : 'once';
@@ -2264,6 +2380,70 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                     }
                 }
+                else if (command.commandName === 'share') {
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.reply({
+                            content: 'This command can only be used in a channel',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const isThread = [
+                        ChannelType.PublicThread,
+                        ChannelType.PrivateThread,
+                        ChannelType.AnnouncementThread,
+                    ].includes(channel.type);
+                    if (!isThread) {
+                        await command.reply({
+                            content: 'This command can only be used in a thread with an active session',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const textChannel = resolveTextChannel(channel);
+                    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+                    if (!directory) {
+                        await command.reply({
+                            content: 'Could not determine project directory for this channel',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const row = getDatabase()
+                        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+                        .get(channel.id);
+                    if (!row?.session_id) {
+                        await command.reply({
+                            content: 'No active session in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const sessionId = row.session_id;
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(directory);
+                        const response = await getClient().session.share({
+                            path: { id: sessionId },
+                        });
+                        if (!response.data?.share?.url) {
+                            await command.reply({
+                                content: 'Failed to generate share URL',
+                                ephemeral: true,
+                            });
+                            return;
+                        }
+                        await command.reply(`🔗 **Session shared:** ${response.data.share.url}`);
+                        sessionLogger.log(`Session ${sessionId} shared: ${response.data.share.url}`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[SHARE] Error:', error);
+                        await command.reply({
+                            content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
             }
         }
         catch (error) {
@@ -2479,7 +2659,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
         }
     });
     await discordClient.login(token);
-    const handleShutdown = async (signal) => {
+    const handleShutdown = async (signal, { skipExit = false } = {}) => {
         discordLogger.log(`Received ${signal}, cleaning up...`);
         // Prevent multiple shutdown calls
         if (global.shuttingDown) {
@@ -2516,12 +2696,16 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
             discordLogger.log('Destroying Discord client...');
             discordClient.destroy();
-            discordLogger.log('Cleanup complete, exiting.');
-            process.exit(0);
+            discordLogger.log('Cleanup complete.');
+            if (!skipExit) {
+                process.exit(0);
+            }
         }
         catch (error) {
             voiceLogger.error('[SHUTDOWN] Error during cleanup:', error);
-            process.exit(1);
+            if (!skipExit) {
+                process.exit(1);
+            }
         }
     };
     // Override default signal handlers to prevent immediate exit
@@ -2543,6 +2727,23 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             process.exit(1);
         }
     });
+    process.on('SIGUSR2', async () => {
+        discordLogger.log('Received SIGUSR2, restarting after cleanup...');
+        try {
+            await handleShutdown('SIGUSR2', { skipExit: true });
+        }
+        catch (error) {
+            voiceLogger.error('[SIGUSR2] Error during shutdown:', error);
+        }
+        const { spawn } = await import('node:child_process');
+        spawn(process.argv[0], [...process.execArgv, ...process.argv.slice(1)], {
+            stdio: 'inherit',
+            detached: true,
+            cwd: process.cwd(),
+            env: process.env,
+        }).unref();
+        process.exit(0);
+    });
     // Prevent unhandled promise rejections from crashing the process during shutdown
     process.on('unhandledRejection', (reason, promise) => {
         if (global.shuttingDown) {

package/dist/genai.js

@@ -169,7 +169,7 @@ export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStar
     const ai = new GoogleGenAI({
         apiKey,
     });
-    const model = 'models/gemini-2.5-flash-live-preview';
+    const model = 'gemini-2.5-flash-native-audio-preview-12-2025';
     session = await ai.live.connect({
         model,
         callbacks: {