kimaki 0.1.5 → 0.2.1

package/dist/cli.js

@@ -7,6 +7,7 @@ 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';
 const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
@@ -75,6 +76,56 @@ async function ensureKimakiCategory(guild) {
 async function run({ restart, addChannels }) {
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
+    // Step 0: Check if OpenCode CLI is available
+    const opencodeCheck = spawnSync('which', ['opencode'], { shell: true });
+    if (opencodeCheck.status !== 0) {
+        note('OpenCode CLI is required but not found in your PATH.', '⚠️  OpenCode Not Found');
+        const shouldInstall = await confirm({
+            message: 'Would you like to install OpenCode right now?',
+        });
+        if (isCancel(shouldInstall) || !shouldInstall) {
+            cancel('OpenCode CLI is required to run this bot');
+            process.exit(0);
+        }
+        const s = spinner();
+        s.start('Installing OpenCode CLI...');
+        try {
+            execSync('curl -fsSL https://opencode.ai/install | bash', {
+                stdio: 'inherit',
+                shell: '/bin/bash',
+            });
+            s.stop('OpenCode CLI installed successfully!');
+            // The install script adds opencode to PATH via shell configuration
+            // For the current process, we need to check common installation paths
+            const possiblePaths = [
+                `${process.env.HOME}/.local/bin/opencode`,
+                `${process.env.HOME}/.opencode/bin/opencode`,
+                '/usr/local/bin/opencode',
+                '/opt/opencode/bin/opencode',
+            ];
+            const installedPath = possiblePaths.find((p) => {
+                try {
+                    fs.accessSync(p, fs.constants.F_OK);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (!installedPath) {
+                note('OpenCode was installed but may not be available in this session.\n' +
+                    'Please restart your terminal and run this command again.', '⚠️  Restart Required');
+                process.exit(0);
+            }
+            // For subsequent spawn calls in this session, we can use the full path
+            process.env.OPENCODE_PATH = installedPath;
+        }
+        catch (error) {
+            s.stop('Failed to install OpenCode CLI');
+            cliLogger.error('Installation error:', error instanceof Error ? error.message : String(error));
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
     const db = getDatabase();
     let appId;
     let token;
@@ -231,7 +282,7 @@ async function run({ restart, addChannels }) {
     s.start('Fetching OpenCode projects...');
     let projects = [];
     try {
-        const projectsResponse = await getClient().project.list();
+        const projectsResponse = await getClient().project.list({});
         if (!projectsResponse.data) {
             throw new Error('Failed to fetch projects');
         }
@@ -270,23 +321,23 @@ async function run({ restart, addChannels }) {
             }
             if (guilds.length === 1) {
                 targetGuild = guilds[0];
+                note(`Using server: ${targetGuild.name}`, 'Server Selected');
             }
             else {
-                const guildId = await text({
-                    message: 'Enter the Discord server ID to create channels in:',
-                    placeholder: guilds[0]?.id,
-                    validate(value) {
-                        if (!value)
-                            return 'Server ID is required';
-                        if (!guilds.find((g) => g.id === value))
-                            return 'Invalid server ID';
-                    },
+                const guildSelection = await multiselect({
+                    message: 'Select a Discord server to create channels in:',
+                    options: guilds.map((guild) => ({
+                        value: guild.id,
+                        label: `${guild.name} (${guild.memberCount} members)`,
+                    })),
+                    required: true,
+                    maxItems: 1,
                 });
-                if (isCancel(guildId)) {
+                if (isCancel(guildSelection)) {
                     cancel('Setup cancelled');
                     process.exit(0);
                 }
-                targetGuild = guilds.find((g) => g.id === guildId);
+                targetGuild = guilds.find((g) => g.id === guildSelection[0]);
             }
             s.start('Creating Discord channels...');
             for (const projectId of selectedProjects) {

package/dist/discordBot.js

@@ -281,7 +281,7 @@ async function setupVoiceHandling({ connection, guildId, channelId, appId, }) {
         });
     });
 }
-export function frameMono16khz() {
+function frameMono16khz() {
     // Hardcoded: 16 kHz, mono, 16-bit PCM, 20 ms -> 320 samples -> 640 bytes
     const FRAME_BYTES = (100 /*ms*/ * 16_000 /*Hz*/ * 1 /*channels*/ * 2) /*bytes per sample*/ /
         1000;
@@ -608,7 +608,8 @@ export async function initializeOpencodeForDirectory(directory) {
     // console.log(
     //   `[OPENCODE] Starting new server on port ${port} for directory: ${directory}`,
     // )
-    const serverProcess = spawn('opencode', ['serve', '--port', port.toString()], {
+    const opencodeCommand = process.env.OPENCODE_PATH || 'opencode';
+    const serverProcess = spawn(opencodeCommand, ['serve', '--port', port.toString()], {
         stdio: 'pipe',
         detached: false,
         cwd: directory,
@@ -648,7 +649,13 @@ export async function initializeOpencodeForDirectory(directory) {
         }
     });
     await waitForServer(port);
-    const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+    const client = createOpencodeClient({
+        baseUrl: `http://localhost:${port}`,
+        fetch: (request) => fetch(request, {
+            // @ts-ignore
+            timeout: false,
+        }),
+    });
     opencodeServers.set(directory, {
         process: serverProcess,
         client,
@@ -730,7 +737,7 @@ function formatPart(part) {
                 const icon = part.state.status === 'completed'
                     ? '◼︎'
                     : part.state.status === 'error'
-                        ? '✖️'
+                        ? '⨯'
                         : '';
                 const title = `${icon} ${part.tool} ${toolTitle}`;
                 let text = title;
@@ -1400,11 +1407,147 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await interaction.respond([]);
                     }
                 }
+                else if (interaction.commandName === 'session') {
+                    const focusedOption = interaction.options.getFocused(true);
+                    if (focusedOption.name === 'files') {
+                        const focusedValue = focusedOption.value;
+                        // Split by comma to handle multiple files
+                        const parts = focusedValue.split(',');
+                        const previousFiles = parts
+                            .slice(0, -1)
+                            .map((f) => f.trim())
+                            .filter((f) => f);
+                        const currentQuery = (parts[parts.length - 1] || '').trim();
+                        // Get the channel's project directory from its topic
+                        let projectDirectory;
+                        if (interaction.channel &&
+                            interaction.channel.type === ChannelType.GuildText) {
+                            const textChannel = resolveTextChannel(interaction.channel);
+                            if (textChannel) {
+                                const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
+                                if (channelAppId && channelAppId !== currentAppId) {
+                                    await interaction.respond([]);
+                                    return;
+                                }
+                                projectDirectory = directory;
+                            }
+                        }
+                        if (!projectDirectory) {
+                            await interaction.respond([]);
+                            return;
+                        }
+                        try {
+                            // Get OpenCode client for this directory
+                            const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                            // Use find.files to search for files based on current query
+                            const response = await getClient().find.files({
+                                query: {
+                                    query: currentQuery || '',
+                                },
+                            });
+                            // Get file paths from the response
+                            const files = response.data || [];
+                            // Build the prefix with previous files
+                            const prefix = previousFiles.length > 0
+                                ? previousFiles.join(', ') + ', '
+                                : '';
+                            // Map to Discord autocomplete format
+                            const choices = files
+                                .slice(0, 25) // Discord limit
+                                .map((file) => {
+                                const fullValue = prefix + file;
+                                // Get all basenames for display
+                                const allFiles = [...previousFiles, file];
+                                const allBasenames = allFiles.map((f) => f.split('/').pop() || f);
+                                let displayName = allBasenames.join(', ');
+                                // Truncate if too long
+                                if (displayName.length > 100) {
+                                    displayName = '…' + displayName.slice(-97);
+                                }
+                                return {
+                                    name: displayName,
+                                    value: fullValue,
+                                };
+                            });
+                            await interaction.respond(choices);
+                        }
+                        catch (error) {
+                            voiceLogger.error('[AUTOCOMPLETE] Error fetching files:', error);
+                            await interaction.respond([]);
+                        }
+                    }
+                }
             }
             // Handle slash commands
             if (interaction.isChatInputCommand()) {
                 const command = interaction;
-                if (command.commandName === 'resume') {
+                if (command.commandName === 'session') {
+                    await command.deferReply({ ephemeral: false });
+                    const prompt = command.options.getString('prompt', true);
+                    const filesString = command.options.getString('files') || '';
+                    const channel = command.channel;
+                    if (!channel || channel.type !== ChannelType.GuildText) {
+                        await command.editReply('This command can only be used in text channels');
+                        return;
+                    }
+                    const textChannel = channel;
+                    // Get project directory from channel topic
+                    let projectDirectory;
+                    let channelAppId;
+                    if (textChannel.topic) {
+                        const extracted = extractTagsArrays({
+                            xml: textChannel.topic,
+                            tags: ['kimaki.directory', 'kimaki.app'],
+                        });
+                        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+                        channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                    }
+                    // Check if this channel belongs to current bot instance
+                    if (channelAppId && channelAppId !== currentAppId) {
+                        await command.editReply('This channel is not configured for this bot');
+                        return;
+                    }
+                    if (!projectDirectory) {
+                        await command.editReply('This channel is not configured with a project directory');
+                        return;
+                    }
+                    if (!fs.existsSync(projectDirectory)) {
+                        await command.editReply(`Directory does not exist: ${projectDirectory}`);
+                        return;
+                    }
+                    try {
+                        // Initialize OpenCode client for the directory
+                        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+                        // Process file mentions - split by comma only
+                        const files = filesString
+                            .split(',')
+                            .map((f) => f.trim())
+                            .filter((f) => f);
+                        // Build the full prompt with file mentions
+                        let fullPrompt = prompt;
+                        if (files.length > 0) {
+                            fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
+                        }
+                        // Send a message first, then create thread from it
+                        const starterMessage = await textChannel.send({
+                            content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+                        });
+                        // Create thread from the message
+                        const thread = await starterMessage.startThread({
+                            name: prompt.slice(0, 100),
+                            autoArchiveDuration: 1440, // 24 hours
+                            reason: 'OpenCode session',
+                        });
+                        await command.editReply(`Created new session in ${thread.toString()}`);
+                        // Start the OpenCode session
+                        await handleOpencodeSession(fullPrompt, thread, projectDirectory);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[SESSION] Error:', error);
+                        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                else if (command.commandName === 'resume') {
                     await command.deferReply({ ephemeral: false });
                     const sessionId = command.options.getString('session', true);
                     const channel = command.channel;
@@ -1476,11 +1619,11 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         for (const message of messages) {
                             if (message.info.role === 'user') {
                                 // Render user messages
-                                const userParts = message.parts.filter((p) => p.type === 'text');
+                                const userParts = message.parts.filter((p) => p.type === 'text' && !p.synthetic);
                                 const userTexts = userParts
                                     .map((p) => {
-                                    if (typeof p.text === 'string') {
-                                        return extractNonXmlContent(p.text);
+                                    if (p.type === 'text') {
+                                        return p.text;
                                     }
                                     return '';
                                 })

package/package.json

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

package/src/cli.ts

@@ -35,6 +35,7 @@ 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'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
@@ -142,6 +143,73 @@ async function run({ restart, addChannels }: CliOptions) {
 
   intro('🤖 Discord Bot Setup')
 
+  // Step 0: Check if OpenCode CLI is available
+  const opencodeCheck = spawnSync('which', ['opencode'], { shell: true })
+
+  if (opencodeCheck.status !== 0) {
+    note(
+      'OpenCode CLI is required but not found in your PATH.',
+      '⚠️  OpenCode Not Found',
+    )
+
+    const shouldInstall = await confirm({
+      message: 'Would you like to install OpenCode right now?',
+    })
+
+    if (isCancel(shouldInstall) || !shouldInstall) {
+      cancel('OpenCode CLI is required to run this bot')
+      process.exit(0)
+    }
+
+    const s = spinner()
+    s.start('Installing OpenCode CLI...')
+
+    try {
+      execSync('curl -fsSL https://opencode.ai/install | bash', {
+        stdio: 'inherit',
+        shell: '/bin/bash',
+      })
+      s.stop('OpenCode CLI installed successfully!')
+
+      // The install script adds opencode to PATH via shell configuration
+      // For the current process, we need to check common installation paths
+      const possiblePaths = [
+        `${process.env.HOME}/.local/bin/opencode`,
+        `${process.env.HOME}/.opencode/bin/opencode`,
+        '/usr/local/bin/opencode',
+        '/opt/opencode/bin/opencode',
+      ]
+
+      const installedPath = possiblePaths.find((p) => {
+        try {
+          fs.accessSync(p, fs.constants.F_OK)
+          return true
+        } catch {
+          return false
+        }
+      })
+
+      if (!installedPath) {
+        note(
+          'OpenCode was installed but may not be available in this session.\n' +
+            'Please restart your terminal and run this command again.',
+          '⚠️  Restart Required',
+        )
+        process.exit(0)
+      }
+
+      // For subsequent spawn calls in this session, we can use the full path
+      process.env.OPENCODE_PATH = installedPath
+    } catch (error) {
+      s.stop('Failed to install OpenCode CLI')
+      cliLogger.error(
+        'Installation error:',
+        error instanceof Error ? error.message : String(error),
+      )
+      process.exit(EXIT_NO_RESTART)
+    }
+  }
+
   const db = getDatabase()
   let appId: string
   let token: string
@@ -377,7 +445,7 @@ async function run({ restart, addChannels }: CliOptions) {
   let projects: Project[] = []
 
   try {
-    const projectsResponse = await getClient().project.list()
+    const projectsResponse = await getClient().project.list({})
     if (!projectsResponse.data) {
       throw new Error('Failed to fetch projects')
     }
@@ -436,22 +504,24 @@ async function run({ restart, addChannels }: CliOptions) {
 
       if (guilds.length === 1) {
         targetGuild = guilds[0]!
+        note(`Using server: ${targetGuild.name}`, 'Server Selected')
       } else {
-        const guildId = await text({
-          message: 'Enter the Discord server ID to create channels in:',
-          placeholder: guilds[0]?.id,
-          validate(value) {
-            if (!value) return 'Server ID is required'
-            if (!guilds.find((g) => g.id === value)) return 'Invalid server ID'
-          },
+        const guildSelection = await multiselect({
+          message: 'Select a Discord server to create channels in:',
+          options: guilds.map((guild) => ({
+            value: guild.id,
+            label: `${guild.name} (${guild.memberCount} members)`,
+          })),
+          required: true,
+          maxItems: 1,
         })
 
-        if (isCancel(guildId)) {
+        if (isCancel(guildSelection)) {
           cancel('Setup cancelled')
           process.exit(0)
         }
 
-        targetGuild = guilds.find((g) => g.id === guildId)!
+        targetGuild = guilds.find((g) => g.id === guildSelection[0])!
       }
 
       s.start('Creating Discord channels...')

package/src/discordBot.ts

@@ -403,7 +403,7 @@ async function setupVoiceHandling({
   })
 }
 
-export function frameMono16khz(): Transform {
+function frameMono16khz(): Transform {
   // Hardcoded: 16 kHz, mono, 16-bit PCM, 20 ms -> 320 samples -> 640 bytes
   const FRAME_BYTES =
     (100 /*ms*/ * 16_000 /*Hz*/ * 1 /*channels*/ * 2) /*bytes per sample*/ /
@@ -822,8 +822,10 @@ export async function initializeOpencodeForDirectory(directory: string) {
   //   `[OPENCODE] Starting new server on port ${port} for directory: ${directory}`,
   // )
 
+  const opencodeCommand = process.env.OPENCODE_PATH || 'opencode'
+
   const serverProcess = spawn(
-    'opencode',
+    opencodeCommand,
     ['serve', '--port', port.toString()],
     {
       stdio: 'pipe',
@@ -876,7 +878,15 @@ export async function initializeOpencodeForDirectory(directory: string) {
   })
 
   await waitForServer(port)
-  const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` })
+
+  const client = createOpencodeClient({
+    baseUrl: `http://localhost:${port}`,
+    fetch: (request: Request) =>
+      fetch(request, {
+        // @ts-ignore
+        timeout: false,
+      }),
+  })
 
   opencodeServers.set(directory, {
     process: serverProcess,
@@ -970,7 +980,7 @@ function formatPart(part: Part): string {
           part.state.status === 'completed'
             ? '◼︎'
             : part.state.status === 'error'
-              ? '✖️'
+              ? '⨯'
               : ''
         const title = `${icon} ${part.tool} ${toolTitle}`
 
@@ -1547,7 +1557,6 @@ export async function startDiscordBot({
       discordLogger.log(`Bot Application ID (provided): ${currentAppId}`)
     }
 
-
     // List all guilds and channels that belong to this bot
     for (const guild of c.guilds.cache.values()) {
       discordLogger.log(`${guild.name} (${guild.id})`)
@@ -1868,6 +1877,93 @@ export async function startDiscordBot({
               )
               await interaction.respond([])
             }
+          } else if (interaction.commandName === 'session') {
+            const focusedOption = interaction.options.getFocused(true)
+
+            if (focusedOption.name === 'files') {
+              const focusedValue = focusedOption.value
+
+              // Split by comma to handle multiple files
+              const parts = focusedValue.split(',')
+              const previousFiles = parts
+                .slice(0, -1)
+                .map((f) => f.trim())
+                .filter((f) => f)
+              const currentQuery = (parts[parts.length - 1] || '').trim()
+
+              // Get the channel's project directory from its topic
+              let projectDirectory: string | undefined
+              if (
+                interaction.channel &&
+                interaction.channel.type === ChannelType.GuildText
+              ) {
+                const textChannel = resolveTextChannel(
+                  interaction.channel as TextChannel | ThreadChannel | null,
+                )
+                if (textChannel) {
+                  const { projectDirectory: directory, channelAppId } =
+                    getKimakiMetadata(textChannel)
+                  if (channelAppId && channelAppId !== currentAppId) {
+                    await interaction.respond([])
+                    return
+                  }
+                  projectDirectory = directory
+                }
+              }
+
+              if (!projectDirectory) {
+                await interaction.respond([])
+                return
+              }
+
+              try {
+                // Get OpenCode client for this directory
+                const getClient =
+                  await initializeOpencodeForDirectory(projectDirectory)
+
+                // Use find.files to search for files based on current query
+                const response = await getClient().find.files({
+                  query: {
+                    query: currentQuery || '',
+                  },
+                })
+
+                // Get file paths from the response
+                const files = response.data || []
+
+                // Build the prefix with previous files
+                const prefix =
+                  previousFiles.length > 0
+                    ? previousFiles.join(', ') + ', '
+                    : ''
+
+                // Map to Discord autocomplete format
+                const choices = files
+                  .slice(0, 25) // Discord limit
+                  .map((file: string) => {
+                    const fullValue = prefix + file
+                    // Get all basenames for display
+                    const allFiles = [...previousFiles, file]
+                    const allBasenames = allFiles.map(
+                      (f) => f.split('/').pop() || f,
+                    )
+                    let displayName = allBasenames.join(', ')
+                    // Truncate if too long
+                    if (displayName.length > 100) {
+                      displayName = '…' + displayName.slice(-97)
+                    }
+                    return {
+                      name: displayName,
+                      value: fullValue,
+                    }
+                  })
+
+                await interaction.respond(choices)
+              } catch (error) {
+                voiceLogger.error('[AUTOCOMPLETE] Error fetching files:', error)
+                await interaction.respond([])
+              }
+            }
           }
         }
 
@@ -1875,7 +1971,100 @@ export async function startDiscordBot({
         if (interaction.isChatInputCommand()) {
           const command = interaction
 
-          if (command.commandName === 'resume') {
+          if (command.commandName === 'session') {
+            await command.deferReply({ ephemeral: false })
+
+            const prompt = command.options.getString('prompt', true)
+            const filesString = command.options.getString('files') || ''
+            const channel = command.channel
+
+            if (!channel || channel.type !== ChannelType.GuildText) {
+              await command.editReply(
+                'This command can only be used in text channels',
+              )
+              return
+            }
+
+            const textChannel = channel as TextChannel
+
+            // Get project directory from channel topic
+            let projectDirectory: string | undefined
+            let channelAppId: string | undefined
+
+            if (textChannel.topic) {
+              const extracted = extractTagsArrays({
+                xml: textChannel.topic,
+                tags: ['kimaki.directory', 'kimaki.app'],
+              })
+
+              projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+              channelAppId = extracted['kimaki.app']?.[0]?.trim()
+            }
+
+            // Check if this channel belongs to current bot instance
+            if (channelAppId && channelAppId !== currentAppId) {
+              await command.editReply(
+                'This channel is not configured for this bot',
+              )
+              return
+            }
+
+            if (!projectDirectory) {
+              await command.editReply(
+                'This channel is not configured with a project directory',
+              )
+              return
+            }
+
+            if (!fs.existsSync(projectDirectory)) {
+              await command.editReply(
+                `Directory does not exist: ${projectDirectory}`,
+              )
+              return
+            }
+
+            try {
+              // Initialize OpenCode client for the directory
+              const getClient =
+                await initializeOpencodeForDirectory(projectDirectory)
+
+              // Process file mentions - split by comma only
+              const files = filesString
+                .split(',')
+                .map((f) => f.trim())
+                .filter((f) => f)
+
+              // Build the full prompt with file mentions
+              let fullPrompt = prompt
+              if (files.length > 0) {
+                fullPrompt = `${prompt}\n\n@${files.join(' @')}`
+              }
+
+              // Send a message first, then create thread from it
+              const starterMessage = await textChannel.send({
+                content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+              })
+
+              // Create thread from the message
+              const thread = await starterMessage.startThread({
+                name: prompt.slice(0, 100),
+                autoArchiveDuration: 1440, // 24 hours
+                reason: 'OpenCode session',
+              })
+
+              await command.editReply(
+                `Created new session in ${thread.toString()}`,
+              )
+
+              // Start the OpenCode session
+              await handleOpencodeSession(fullPrompt, thread, projectDirectory)
+            } catch (error) {
+              voiceLogger.error('[SESSION] Error:', error)
+              await command.editReply(
+                `Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+              )
+            }
+          } else if (command.commandName === 'resume') {
             await command.deferReply({ ephemeral: false })
 
             const sessionId = command.options.getString('session', true)
@@ -1988,12 +2177,12 @@ export async function startDiscordBot({
                 if (message.info.role === 'user') {
                   // Render user messages
                   const userParts = message.parts.filter(
-                    (p) => p.type === 'text',
+                    (p) => p.type === 'text' && !p.synthetic,
                   )
                   const userTexts = userParts
                     .map((p) => {
-                      if (typeof p.text === 'string') {
-                        return extractNonXmlContent(p.text)
+                      if (p.type === 'text') {
+                        return p.text
                       }
                       return ''
                     })