kimaki 0.4.4 → 0.4.7

package/dist/cli.js

@@ -7,10 +7,23 @@ import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord
 import path from 'node:path';
 import fs from 'node:fs';
 import { createLogger } from './logger.js';
-import { spawnSync, execSync } from 'node:child_process';
+import { spawn, spawnSync, execSync } from 'node:child_process';
 const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
+process.on('SIGUSR2', () => {
+    cliLogger.info('Received SIGUSR2, restarting process in 1000ms...');
+    setTimeout(() => {
+        cliLogger.info('Restarting...');
+        spawn(process.argv[0], [...process.execArgv, ...process.argv.slice(1)], {
+            stdio: 'inherit',
+            detached: true,
+            cwd: process.cwd(),
+            env: process.env,
+        }).unref();
+        process.exit(0);
+    }, 1000);
+});
 const EXIT_NO_RESTART = 64;
 async function registerCommands(token, appId) {
     const commands = [
@@ -57,6 +70,18 @@ async function registerCommands(token, appId) {
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('accept')
+            .setDescription('Accept a pending permission request (this request only)')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('accept-always')
+            .setDescription('Accept and auto-approve future requests matching this pattern (e.g. "git *" approves all git commands)')
+            .toJSON(),
+        new SlashCommandBuilder()
+            .setName('reject')
+            .setDescription('Reject a pending permission request')
+            .toJSON(),
     ];
     const rest = new REST().setToken(token);
     try {

package/dist/discordBot.js

@@ -35,6 +35,8 @@ const abortControllers = new Map();
 const voiceConnections = new Map();
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map();
+// Map of thread ID to pending permission (only one pending permission per thread)
+const pendingPermissions = new Map();
 let db = null;
 function convertToMono16k(buffer) {
     // Parameters
@@ -595,6 +597,15 @@ 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) => ({
+        type: 'file',
+        mime: attachment.contentType || 'image/png',
+        filename: attachment.name,
+        url: attachment.url,
+    }));
+}
 export function escapeBackticksInCodeBlocks(markdown) {
     const lexer = new Lexer();
     const tokens = lexer.lex(markdown);
@@ -873,7 +884,7 @@ function formatPart(part) {
         const outputToDisplay = getToolOutputToDisplay(part);
         let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error';
         if (toolTitle) {
-            toolTitle = `\`${escapeInlineCode(toolTitle)}\``;
+            toolTitle = `*${toolTitle}*`;
         }
         const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : '';
         const title = `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
@@ -901,7 +912,7 @@ export async function createDiscordClient() {
         ],
     });
 }
-async function handleOpencodeSession(prompt, thread, projectDirectory, originalMessage) {
+async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], }) {
     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();
@@ -1151,6 +1162,38 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
                     }
                     break;
                 }
+                else if (event.type === 'permission.updated') {
+                    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 || '';
+                    const permissionMessage = await sendThreadMessage(thread, `⚠️ **Permission Required**\n\n` +
+                        `**Type:** \`${permission.type}\`\n` +
+                        `**Action:** ${permission.title}\n` +
+                        (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+                        `\nUse \`/accept\` or \`/reject\` to respond.`);
+                    pendingPermissions.set(thread.id, {
+                        permission,
+                        messageId: permissionMessage.id,
+                        directory,
+                    });
+                }
+                else if (event.type === 'permission.replied') {
+                    const { permissionID, response, sessionID } = event.properties;
+                    if (sessionID !== session.id) {
+                        continue;
+                    }
+                    sessionLogger.log(`Permission ${permissionID} replied with: ${response}`);
+                    const pending = pendingPermissions.get(thread.id);
+                    if (pending && pending.permission.id === permissionID) {
+                        pendingPermissions.delete(thread.id);
+                    }
+                }
                 else if (event.type === 'file.edited') {
                     sessionLogger.log(`File edited event received`);
                 }
@@ -1211,12 +1254,17 @@ async function handleOpencodeSession(prompt, thread, projectDirectory, originalM
     };
     try {
         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) })));
+        }
         // Start the event handler
         const eventHandlerPromise = eventHandler();
+        const parts = [{ type: 'text', text: prompt }, ...images];
+        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
         const response = await getClient().session.prompt({
             path: { id: session.id },
             body: {
-                parts: [{ type: 'text', text: prompt }],
+                parts,
             },
             signal: abortController.signal,
         });
@@ -1407,7 +1455,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                await handleOpencodeSession(messageContent, thread, projectDirectory, message);
+                const images = getImageAttachments(message);
+                await handleOpencodeSession({
+                    prompt: messageContent,
+                    thread,
+                    projectDirectory,
+                    originalMessage: message,
+                    images,
+                });
                 return;
             }
             // For text channels, start new sessions with kimaki.directory tag
@@ -1466,7 +1521,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 if (transcription) {
                     messageContent = transcription;
                 }
-                await handleOpencodeSession(messageContent, thread, projectDirectory, message);
+                const images = getImageAttachments(message);
+                await handleOpencodeSession({
+                    prompt: messageContent,
+                    thread,
+                    projectDirectory,
+                    originalMessage: message,
+                    images,
+                });
             }
             else {
                 discordLogger.log(`Channel type ${channel.type} is not supported`);
@@ -1721,7 +1783,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         await command.editReply(`Created new session in ${thread.toString()}`);
                         // Start the OpenCode session
-                        await handleOpencodeSession(fullPrompt, thread, projectDirectory);
+                        await handleOpencodeSession({
+                            prompt: fullPrompt,
+                            thread,
+                            projectDirectory,
+                        });
                     }
                     catch (error) {
                         voiceLogger.error('[SESSION] Error:', error);
@@ -1818,16 +1884,26 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                             }
                             else if (message.info.role === 'assistant') {
                                 // Render assistant parts
+                                const partsToRender = [];
                                 for (const part of message.parts) {
                                     const content = formatPart(part);
                                     if (content.trim()) {
-                                        const discordMessage = await sendThreadMessage(thread, content);
-                                        // Store part-message mapping in database
-                                        getDatabase()
-                                            .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
-                                            .run(part.id, discordMessage.id, thread.id);
+                                        partsToRender.push({ id: part.id, content });
                                     }
                                 }
+                                if (partsToRender.length > 0) {
+                                    const combinedContent = partsToRender
+                                        .map((p) => p.content)
+                                        .join('\n\n');
+                                    const discordMessage = await sendThreadMessage(thread, combinedContent);
+                                    const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+                                    const transaction = getDatabase().transaction((parts) => {
+                                        for (const part of parts) {
+                                            stmt.run(part.id, discordMessage.id, thread.id);
+                                        }
+                                    });
+                                    transaction(partsToRender);
+                                }
                             }
                             messageCount++;
                         }
@@ -1885,6 +1961,115 @@ 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 === 'accept' ||
+                    command.commandName === 'accept-always') {
+                    const scope = command.commandName === 'accept-always' ? 'always' : 'once';
+                    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 pending = pendingPermissions.get(channel.id);
+                    if (!pending) {
+                        await command.reply({
+                            content: 'No pending permission request in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(pending.directory);
+                        await getClient().postSessionIdPermissionsPermissionId({
+                            path: {
+                                id: pending.permission.sessionID,
+                                permissionID: pending.permission.id,
+                            },
+                            body: {
+                                response: scope,
+                            },
+                        });
+                        pendingPermissions.delete(channel.id);
+                        const msg = scope === 'always'
+                            ? `✅ Permission **accepted** (auto-approve similar requests)`
+                            : `✅ Permission **accepted**`;
+                        await command.reply(msg);
+                        sessionLogger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ACCEPT] Error:', error);
+                        await command.reply({
+                            content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
+                else if (command.commandName === 'reject') {
+                    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 pending = pendingPermissions.get(channel.id);
+                    if (!pending) {
+                        await command.reply({
+                            content: 'No pending permission request in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    try {
+                        const getClient = await initializeOpencodeForDirectory(pending.directory);
+                        await getClient().postSessionIdPermissionsPermissionId({
+                            path: {
+                                id: pending.permission.sessionID,
+                                permissionID: pending.permission.id,
+                            },
+                            body: {
+                                response: 'reject',
+                            },
+                        });
+                        pendingPermissions.delete(channel.id);
+                        await command.reply(`❌ Permission **rejected**`);
+                        sessionLogger.log(`Permission ${pending.permission.id} rejected`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[REJECT] Error:', error);
+                        await command.reply({
+                            content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
             }
         }
         catch (error) {

package/dist/tools.js

@@ -95,7 +95,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     .optional()
                     .describe('Optional model to use for this session'),
             }),
-            execute: async ({ message, title, model }) => {
+            execute: async ({ message, title, }) => {
                 if (!message.trim()) {
                     throw new Error(`message must be a non empty string`);
                 }
@@ -114,6 +114,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
+                            // model,
                         },
                     })
                         .then(async (response) => {

package/package.json

@@ -2,7 +2,17 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.4",
+  "version": "0.4.7",
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "prepublishOnly": "pnpm tsc",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
+  },
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -24,7 +34,7 @@
     "@discordjs/opus": "^0.10.0",
     "@discordjs/voice": "^0.19.0",
     "@google/genai": "^1.16.0",
-    "@opencode-ai/sdk": "^0.11.0",
+    "@opencode-ai/sdk": "^1.0.115",
     "@purinton/resampler": "^1.0.4",
     "@snazzah/davey": "^0.1.6",
     "ai": "^5.0.29",
@@ -43,14 +53,5 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "dev": "pnpm tsc && tsx --env-file .env src/cli.ts",
-    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
-    "watch": "tsx scripts/watch-session.ts",
-    "test:events": "tsx test-events.ts",
-    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
-    "test:send": "tsx send-test-message.ts",
-    "register-commands": "tsx scripts/register-commands.ts"
   }
-}
+}

package/src/cli.ts

@@ -37,13 +37,27 @@ import {
 import path from 'node:path'
 import fs from 'node:fs'
 import { createLogger } from './logger.js'
-import { spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
+import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
 
 process.title = 'kimaki'
 
+process.on('SIGUSR2', () => {
+  cliLogger.info('Received SIGUSR2, restarting process in 1000ms...')
+  setTimeout(() => {
+    cliLogger.info('Restarting...')
+    spawn(process.argv[0]!, [...process.execArgv, ...process.argv.slice(1)], {
+      stdio: 'inherit',
+      detached: true,
+      cwd: process.cwd(),
+      env: process.env,
+    }).unref()
+    process.exit(0)
+  }, 1000)
+})
+
 const EXIT_NO_RESTART = 64
 
 type Project = {
@@ -112,6 +126,18 @@ async function registerCommands(token: string, appId: string) {
         return option
       })
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('accept')
+      .setDescription('Accept a pending permission request (this request only)')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('accept-always')
+      .setDescription('Accept and auto-approve future requests matching this pattern (e.g. "git *" approves all git commands)')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('reject')
+      .setDescription('Reject a pending permission request')
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)

package/src/discordBot.ts

@@ -3,6 +3,8 @@ import {
   type OpencodeClient,
   type Part,
   type Config,
+  type FilePartInput,
+  type Permission,
 } from '@opencode-ai/sdk'
 
 import { createGenAIWorker, type GenAIWorker } from './genai-worker-wrapper.js'
@@ -89,6 +91,12 @@ const voiceConnections = new Map<
 // Map of directory to retry count for server restarts
 const serverRetryCount = new Map<string, number>()
 
+// Map of thread ID to pending permission (only one pending permission per thread)
+const pendingPermissions = new Map<
+  string,
+  { permission: Permission; messageId: string; directory: string }
+>()
+
 let db: Database.Database | null = null
 
 function convertToMono16k(buffer: Buffer): Buffer {
@@ -813,6 +821,19 @@ async function processVoiceAttachment({
   return transcription
 }
 
+function getImageAttachments(message: Message): FilePartInput[] {
+  const imageAttachments = Array.from(message.attachments.values()).filter(
+    (attachment) => attachment.contentType?.startsWith('image/'),
+  )
+
+  return imageAttachments.map((attachment) => ({
+    type: 'file' as const,
+    mime: attachment.contentType || 'image/png',
+    filename: attachment.name,
+    url: attachment.url,
+  }))
+}
+
 export function escapeBackticksInCodeBlocks(markdown: string): string {
   const lexer = new Lexer()
   const tokens = lexer.lex(markdown)
@@ -1160,7 +1181,7 @@ function formatPart(part: Part): string {
 
     let toolTitle = part.state.status === 'completed' ? part.state.title || '' : 'error'
     if (toolTitle) {
-      toolTitle = `\`${escapeInlineCode(toolTitle)}\``
+      toolTitle = `*${toolTitle}*`
     }
 
     const icon = part.state.status === 'completed' ? '◼︎' : part.state.status === 'error' ? '⨯' : ''
@@ -1193,12 +1214,19 @@ export async function createDiscordClient() {
   })
 }
 
-async function handleOpencodeSession(
-  prompt: string,
-  thread: ThreadChannel,
-  projectDirectory?: string,
-  originalMessage?: Message,
-): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
+async function handleOpencodeSession({
+  prompt,
+  thread,
+  projectDirectory,
+  originalMessage,
+  images = [],
+}: {
+  prompt: string
+  thread: ThreadChannel
+  projectDirectory?: string
+  originalMessage?: Message
+  images?: FilePartInput[]
+}): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
   voiceLogger.log(
     `[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
   )
@@ -1526,6 +1554,51 @@ async function handleOpencodeSession(
             )
           }
           break
+        } else if (event.type === 'permission.updated') {
+          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 || ''
+
+          const permissionMessage = await sendThreadMessage(
+            thread,
+            `⚠️ **Permission Required**\n\n` +
+              `**Type:** \`${permission.type}\`\n` +
+              `**Action:** ${permission.title}\n` +
+              (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+              `\nUse \`/accept\` or \`/reject\` to respond.`,
+          )
+
+          pendingPermissions.set(thread.id, {
+            permission,
+            messageId: permissionMessage.id,
+            directory,
+          })
+        } else if (event.type === 'permission.replied') {
+          const { permissionID, response, sessionID } = event.properties
+          if (sessionID !== session.id) {
+            continue
+          }
+
+          sessionLogger.log(
+            `Permission ${permissionID} replied with: ${response}`,
+          )
+
+          const pending = pendingPermissions.get(thread.id)
+          if (pending && pending.permission.id === permissionID) {
+            pendingPermissions.delete(thread.id)
+          }
         } else if (event.type === 'file.edited') {
           sessionLogger.log(`File edited event received`)
         } else {
@@ -1600,14 +1673,20 @@ async function handleOpencodeSession(
     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) })))
+    }
 
     // Start the event handler
     const eventHandlerPromise = eventHandler()
 
+    const parts = [{ type: 'text' as const, text: prompt }, ...images]
+    sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
+
     const response = await getClient().session.prompt({
       path: { id: session.id },
       body: {
-        parts: [{ type: 'text', text: prompt }],
+        parts,
       },
       signal: abortController.signal,
     })
@@ -1874,12 +1953,14 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        await handleOpencodeSession(
-          messageContent,
+        const images = getImageAttachments(message)
+        await handleOpencodeSession({
+          prompt: messageContent,
           thread,
           projectDirectory,
-          message,
-        )
+          originalMessage: message,
+          images,
+        })
         return
       }
 
@@ -1967,12 +2048,14 @@ export async function startDiscordBot({
           messageContent = transcription
         }
 
-        await handleOpencodeSession(
-          messageContent,
+        const images = getImageAttachments(message)
+        await handleOpencodeSession({
+          prompt: messageContent,
           thread,
           projectDirectory,
-          message,
-        )
+          originalMessage: message,
+          images,
+        })
       } else {
         discordLogger.log(`Channel type ${channel.type} is not supported`)
       }
@@ -2307,7 +2390,11 @@ export async function startDiscordBot({
               )
 
               // Start the OpenCode session
-              await handleOpencodeSession(fullPrompt, thread, projectDirectory)
+              await handleOpencodeSession({
+                prompt: fullPrompt,
+                thread,
+                projectDirectory,
+              })
             } catch (error) {
               voiceLogger.error('[SESSION] Error:', error)
               await command.editReply(
@@ -2446,22 +2533,39 @@ export async function startDiscordBot({
                   }
                 } else if (message.info.role === 'assistant') {
                   // Render assistant parts
+                  const partsToRender: { id: string; content: string }[] = []
+
                   for (const part of message.parts) {
                     const content = formatPart(part)
                     if (content.trim()) {
-                      const discordMessage = await sendThreadMessage(
-                        thread,
-                        content,
-                      )
-
-                      // Store part-message mapping in database
-                      getDatabase()
-                        .prepare(
-                          'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
-                        )
-                        .run(part.id, discordMessage.id, thread.id)
+                      partsToRender.push({ id: part.id, content })
                     }
                   }
+
+                  if (partsToRender.length > 0) {
+                    const combinedContent = partsToRender
+                      .map((p) => p.content)
+                      .join('\n\n')
+
+                    const discordMessage = await sendThreadMessage(
+                      thread,
+                      combinedContent,
+                    )
+
+                    const stmt = getDatabase().prepare(
+                      'INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)',
+                    )
+
+                    const transaction = getDatabase().transaction(
+                      (parts: { id: string }[]) => {
+                        for (const part of parts) {
+                          stmt.run(part.id, discordMessage.id, thread.id)
+                        }
+                      },
+                    )
+
+                    transaction(partsToRender)
+                  }
                 }
                 messageCount++
               }
@@ -2547,6 +2651,128 @@ export async function startDiscordBot({
                 `Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`,
               )
             }
+          } else if (
+            command.commandName === 'accept' ||
+            command.commandName === 'accept-always'
+          ) {
+            const scope = command.commandName === 'accept-always' ? 'always' : 'once'
+            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 pending = pendingPermissions.get(channel.id)
+            if (!pending) {
+              await command.reply({
+                content: 'No pending permission request in this thread',
+                ephemeral: true,
+              })
+              return
+            }
+
+            try {
+              const getClient = await initializeOpencodeForDirectory(pending.directory)
+              await getClient().postSessionIdPermissionsPermissionId({
+                path: {
+                  id: pending.permission.sessionID,
+                  permissionID: pending.permission.id,
+                },
+                body: {
+                  response: scope,
+                },
+              })
+
+              pendingPermissions.delete(channel.id)
+              const msg =
+                scope === 'always'
+                  ? `✅ Permission **accepted** (auto-approve similar requests)`
+                  : `✅ Permission **accepted**`
+              await command.reply(msg)
+              sessionLogger.log(
+                `Permission ${pending.permission.id} accepted with scope: ${scope}`,
+              )
+            } catch (error) {
+              voiceLogger.error('[ACCEPT] Error:', error)
+              await command.reply({
+                content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
+          } else if (command.commandName === 'reject') {
+            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 pending = pendingPermissions.get(channel.id)
+            if (!pending) {
+              await command.reply({
+                content: 'No pending permission request in this thread',
+                ephemeral: true,
+              })
+              return
+            }
+
+            try {
+              const getClient = await initializeOpencodeForDirectory(pending.directory)
+              await getClient().postSessionIdPermissionsPermissionId({
+                path: {
+                  id: pending.permission.sessionID,
+                  permissionID: pending.permission.id,
+                },
+                body: {
+                  response: 'reject',
+                },
+              })
+
+              pendingPermissions.delete(channel.id)
+              await command.reply(`❌ Permission **rejected**`)
+              sessionLogger.log(`Permission ${pending.permission.id} rejected`)
+            } catch (error) {
+              voiceLogger.error('[REJECT] Error:', error)
+              await command.reply({
+                content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ephemeral: true,
+              })
+            }
           }
         }
       } catch (error) {

package/src/tools.ts

@@ -127,7 +127,7 @@ export async function getTools({
           .optional()
           .describe('Optional model to use for this session'),
       }),
-      execute: async ({ message, title, model }) => {
+      execute: async ({ message, title,  }) => {
         if (!message.trim()) {
           throw new Error(`message must be a non empty string`)
         }
@@ -149,6 +149,7 @@ export async function getTools({
               path: { id: session.data.id },
               body: {
                 parts: [{ type: 'text', text: message }],
+                // model,
               },
             })
             .then(async (response) => {