bimmo-cli 2.0.1 → 2.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bimmo-cli",
-  "version": "2.0.1",
-  "description": "🌿 Plataforma de Orquestração de Agentes IA (Swarms) com interface verde/lavanda, modo Auto-Edit e contexto inteligente.",
+  "version": "2.1.0",
+  "description": "🌿 Plataforma de IA universal com Modo Normal, Agentes e Swarms. Suporte a Diffs coloridos, Auto-Edit (Auto/Manual) e Contexto Inteligente.",
   "bin": {
     "bimmo": "bin/bimmo"
   },
@@ -18,7 +18,7 @@
     "zai",
     "agent",
     "swarm",
-    "orchestration",
+    "diff",
     "multimodal",
     "terminal"
   ],
@@ -40,6 +40,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "conf": "^13.0.0",
+    "diff": "^7.0.0",
     "figlet": "^1.7.0",
     "inquirer": "^10.1.0",
     "marked": "^14.0.0",

package/src/agent.js

@@ -3,10 +3,18 @@ import fs from 'fs';
 import path from 'path';
 import { execSync } from 'child_process';
 import { getConfig } from './config.js';
+import * as diff from 'diff';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
 
 const config = getConfig();
 const tvly = config.tavilyKey ? tavily({ apiKey: config.tavilyKey }) : null;
 
+// Estado global para controle de edições (temporário na sessão)
+export const editState = {
+  autoAccept: false
+};
+
 export const tools = [
   {
     name: 'search_internet',
@@ -55,17 +63,69 @@ export const tools = [
     parameters: {
       type: 'object',
       properties: {
-        path: { type: 'string', description: 'Camin de destino' },
+        path: { type: 'string', description: 'Caminho de destino' },
         content: { type: 'string', description: 'Conteúdo do arquivo' }
       },
       required: ['path', 'content']
     },
     execute: async ({ path: filePath, content }) => {
       try {
-        const dir = path.dirname(filePath);
+        const absolutePath = path.resolve(filePath);
+        const oldContent = fs.existsSync(absolutePath) ? fs.readFileSync(absolutePath, 'utf-8') : "";
+        
+        // Gerar Diff
+        const differences = diff.diffLines(oldContent, content);
+        
+        console.log(`\n${chalk.cyan('📝 Alterações propostas em:')} ${chalk.bold(filePath)}`);
+        console.log(chalk.gray('─'.repeat(40)));
+        
+        let hasChanges = false;
+        differences.forEach((part) => {
+          if (part.added || part.removed) hasChanges = true;
+          const color = part.added ? chalk.green : part.removed ? chalk.red : chalk.gray;
+          const prefix = part.added ? '+' : part.removed ? '-' : ' ';
+          
+          // Mostra apenas linhas com mudanças ou um pouco de contexto
+          if (part.added || part.removed) {
+            process.stdout.write(color(`${prefix} ${part.value}`));
+          } else {
+            // Mostra apenas as primeiras e últimas linhas de blocos sem mudança para encurtar
+            const lines = part.value.split('\n');
+            if (lines.length > 4) {
+              process.stdout.write(color(`  ${lines[0]}\n  ...\n  ${lines[lines.length-2]}\n`));
+            } else {
+              process.stdout.write(color(`  ${part.value}`));
+            }
+          }
+        });
+        console.log(chalk.gray('\n' + '─'.repeat(40)));
+
+        if (!hasChanges) {
+          return "Nenhuma mudança detectada no arquivo.";
+        }
+
+        // Lógica de Aprovação
+        if (!editState.autoAccept) {
+          const { approve } = await inquirer.prompt([{
+            type: 'list',
+            name: 'approve',
+            message: 'Deseja aplicar estas alterações?',
+            choices: [
+              { name: '✅ Sim', value: 'yes' },
+              { name: '❌ Não', value: 'no' },
+              { name: '⚡ Sim para tudo (Auto-Accept)', value: 'all' }
+            ]
+          }]);
+
+          if (approve === 'no') return "Alteração rejeitada pelo usuário.";
+          if (approve === 'all') editState.autoAccept = true;
+        }
+
+        const dir = path.dirname(absolutePath);
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(filePath, content);
-        return `Arquivo ${filePath} criado com sucesso.`;
+        fs.writeFileSync(absolutePath, content);
+        
+        return `Arquivo ${filePath} atualizado com sucesso.`;
       } catch (err) {
         return `Erro ao escrever arquivo: ${err.message}`;
       }
@@ -83,8 +143,26 @@ export const tools = [
     },
     execute: async ({ command }) => {
       try {
-        const output = execSync(command, { encoding: 'utf-8', timeout: 30000 });
-        return output || 'Comando executado sem retorno visual.';
+        console.log(`\n${chalk.yellow('⚠️  Comando proposto:')} ${chalk.bold(command)}`);
+        
+        if (!editState.autoAccept) {
+          const { approve } = await inquirer.prompt([{
+            type: 'list',
+            name: 'approve',
+            message: 'Executar este comando?',
+            choices: [
+              { name: '✅ Sim', value: 'yes' },
+              { name: '❌ Não', value: 'no' },
+              { name: '⚡ Sim para tudo (Auto-Accept)', value: 'all' }
+            ]
+          }]);
+
+          if (approve === 'no') return "Comando rejeitado pelo usuário.";
+          if (approve === 'all') editState.autoAccept = true;
+        }
+
+        const output = execSync(command, { encoding: 'utf-8', timeout: 60000 });
+        return output || 'Comando executado com sucesso (sem retorno).';
       } catch (err) {
         return `Erro ao executar comando: ${err.stderr || err.message}`;
       }
@@ -97,7 +175,6 @@ export async function handleToolCalls(toolCalls) {
   for (const call of toolCalls) {
     const tool = tools.find(t => t.name === call.name);
     if (tool) {
-      console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
       const result = await tool.execute(call.args);
       results.push({
         callId: call.id,

package/src/interface.js

@@ -13,6 +13,7 @@ import { getConfig, configure, updateActiveModel, switchProfile } from './config
 import { createProvider } from './providers/factory.js';
 import { getProjectContext } from './project-context.js';
 import { SwarmOrchestrator } from './orchestrator.js';
+import { editState } from './agent.js';
 
 marked.use(new TerminalRenderer({
   heading: chalk.hex('#c084fc').bold,
@@ -25,7 +26,10 @@ const gray = chalk.gray;
 const bold = chalk.bold;
 const yellow = chalk.yellow;
 
-let currentMode = 'chat'; // 'chat', 'plan', 'edit'
+let currentMode = 'chat'; 
+let activePersona = null; 
+let exitCounter = 0;
+let exitTimer = null;
 
 async function processInput(input) {
   const parts = input.split(' ');
@@ -93,10 +97,13 @@ async function processInput(input) {
 }
 
 function getModeStyle() {
+  const personaLabel = activePersona ? `[${activePersona.toUpperCase()}] ` : '';
   switch (currentMode) {
-    case 'plan': return yellow.bold(' [PLAN] ');
-    case 'edit': return chalk.red.bold(' [EDIT] ');
-    default: return lavender.bold(' [CHAT] ');
+    case 'plan': return yellow.bold(`${personaLabel}[PLAN] `);
+    case 'edit': 
+      const editSubMode = editState.autoAccept ? '(AUTO)' : '(MANUAL)';
+      return chalk.red.bold(`${personaLabel}[EDIT${editSubMode}] `);
+    default: return lavender.bold(`${personaLabel}[CHAT] `);
   }
 }
 
@@ -112,37 +119,64 @@ export async function startInteractive() {
 
   let provider = createProvider(config);
   const orchestrator = new SwarmOrchestrator(config);
-  const messages = [];
+  let messages = [];
+
+  const resetMessages = () => {
+    messages = [];
+    const projectContext = getProjectContext();
+    messages.push({ role: 'system', content: projectContext });
+    if (activePersona) {
+      const agent = (config.agents || {})[activePersona];
+      if (agent) {
+        messages.push({ role: 'system', content: `Sua persona atual é: ${agent.name}. Sua tarefa: ${agent.role}` });
+      }
+    }
+  };
 
-  const projectContext = getProjectContext();
-  messages.push({ 
-    role: 'system', 
-    content: projectContext 
-  });
+  resetMessages();
 
   console.clear();
   console.log(lavender(figlet.textSync('bimmo')));
   console.log(lavender('─'.repeat(60)));
-  console.log(green(`   Perfil Ativo: ${bold(config.activeProfile || 'Padrão')} (${config.provider.toUpperCase()})`));
+  console.log(green(`   Perfil: ${bold(config.activeProfile || 'Padrão')} • IA: ${bold(config.provider.toUpperCase())}`));
   console.log(green(`   Modelo: ${bold(config.model)}`));
-  console.log(gray('   /chat | /plan | /edit | /swarm | /switch [perfil] | /model [novo] | /help'));
+  console.log(gray('   /chat | /plan | /edit | /swarm | /use [agente] | /help'));
   console.log(lavender('─'.repeat(60)) + '\n');
 
-  console.log(lavender('👋 Olá! Sou seu agente BIMMO. No que posso atuar?\n'));
+  console.log(lavender('👋 Olá! Estou pronto. No que posso ajudar?\n'));
+
+  process.on('SIGINT', () => {
+    exitCounter++;
+    if (exitCounter === 1) {
+      console.log(gray('\n(Pressione Ctrl+C novamente para sair)'));
+      if (exitTimer) clearTimeout(exitTimer);
+      exitTimer = setTimeout(() => { exitCounter = 0; }, 2000);
+    } else {
+      console.log(lavender('\n👋 BIMMO encerrando sessão. Até logo!\n'));
+      process.exit(0);
+    }
+  });
 
   readline.emitKeypressEvents(process.stdin);
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
   while (true) {
     const modeIndicator = getModeStyle();
-    const { input } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'input',
-        message: modeIndicator + green('Você'),
-        prefix: '→',
-      }
-    ]);
+    let input;
+    
+    try {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'input',
+          message: modeIndicator + green('Você'),
+          prefix: '→',
+        }
+      ]);
+      input = answers.input;
+    } catch (e) {
+      continue;
+    }
 
     const rawInput = input.trim();
     const cmd = rawInput.toLowerCase();
@@ -154,35 +188,65 @@ export async function startInteractive() {
 
     if (cmd === '/chat') { currentMode = 'chat'; console.log(lavender('✓ Modo CHAT.\n')); continue; }
     if (cmd === '/plan') { currentMode = 'plan'; console.log(yellow('✓ Modo PLAN.\n')); continue; }
-    if (cmd === '/edit') { currentMode = 'edit'; console.log(chalk.red('⚠️  Modo EDIT.\n')); continue; }
+    
+    if (cmd === '/edit') { 
+      currentMode = 'edit'; 
+      console.log(chalk.red(`⚠️  Modo EDIT ativado (Sub-modo atual: ${editState.autoAccept ? 'AUTO' : 'MANUAL'}).\n`)); 
+      continue; 
+    }
+    if (cmd === '/edit auto') {
+      currentMode = 'edit';
+      editState.autoAccept = true;
+      console.log(chalk.red('⚠️  Modo EDIT (AUTO) ativado. Mudanças serão aplicadas sem perguntar.\n'));
+      continue;
+    }
+    if (cmd === '/edit manual') {
+      currentMode = 'edit';
+      editState.autoAccept = false;
+      console.log(chalk.red('⚠️  Modo EDIT (MANUAL) ativado. Pedirei permissão para cada mudança.\n'));
+      continue;
+    }
 
     if (cmd.startsWith('/switch ')) {
       const profileName = rawInput.split(' ')[1];
       if (profileName && switchProfile(profileName)) {
         config = getConfig();
         provider = createProvider(config);
-        console.log(green(`\n✓ Trocado para o perfil "${bold(profileName)}"!`));
-        console.log(gray(`   IA: ${config.provider.toUpperCase()} | Modelo: ${config.model}\n`));
-      } else {
-        console.log(chalk.red(`\n✖ Perfil "${profileName}" não encontrado.\n`));
+        console.log(green(`\n✓ Perfil "${bold(profileName)}" ativado!`));
+        continue;
       }
+      console.log(chalk.red(`\n✖ Perfil não encontrado.\n`));
       continue;
     }
 
-    if (cmd.startsWith('/model ')) {
-      const newModel = rawInput.split(' ')[1];
-      if (newModel) {
-        updateActiveModel(newModel);
-        config.model = newModel;
-        provider = createProvider(config);
-        console.log(green(`\n✓ Modelo atualizado para: ${bold(newModel)}\n`));
+    if (cmd.startsWith('/use ')) {
+      const agentName = rawInput.split(' ')[1];
+      const agents = config.agents || {};
+      if (agentName === 'normal' || agentName === 'default') {
+        activePersona = null;
+        console.log(lavender(`\n✓ Voltando para o Modo Normal.\n`));
+        resetMessages();
+        continue;
+      }
+      if (agents[agentName]) {
+        activePersona = agentName;
+        const agent = agents[agentName];
+        if (switchProfile(agent.profile)) {
+          config = getConfig();
+          provider = createProvider(config);
+        }
+        currentMode = agent.mode || 'chat';
+        console.log(green(`\n✓ Agora você está falando com o Agente: ${bold(agentName)}`));
+        console.log(gray(`   Task: ${agent.role.substring(0, 100)}...\n`));
+        resetMessages();
+      } else {
+        console.log(chalk.red(`\n✖ Agente "${agentName}" não encontrado.\n`));
       }
       continue;
     }
 
     if (cmd === '/clear') {
-      messages.length = 0;
-      messages.push({ role: 'system', content: getProjectContext() });
+      resetMessages();
       console.clear();
       console.log(lavender('✓ Histórico limpo, contexto preservado.\n'));
       continue;
@@ -190,73 +254,79 @@ export async function startInteractive() {
 
     if (cmd === '/help') {
       console.log(gray(`
-Comandos Disponíveis:
-  /chat /plan /edit → Mudar modo de operação
-  /switch [nome]   → Mudar PERFIL (IA completa)
-  /model [nome]    → Mudar apenas o MODELO atual
-  /swarm           → Configurar e rodar enxames de agentes
-  /config          → Gerenciar perfis e agentes
+Comandos de Modo:
+  /chat            → Modo conversa
+  /plan            → Modo planejamento
+  /edit [auto/manual] → Modo edição (padrão manual)
+  /use [agente]    → Usar um Agente Especialista
+  /use normal      → Voltar para o chat normal
+  /swarm           → Rodar fluxos complexos
+
+Gerenciamento:
+  /switch [nome]   → Mudar perfil de IA completo
+  /model [nome]    → Mudar modelo atual
+  /config          → Perfis e Agentes
   /init            → Inicializar .bimmorc.json
-  @caminho         → Anexar arquivos ou imagens
+  @arquivo         → Ler arquivo ou imagem
       `));
       continue;
     }
 
     if (cmd === '/config') { await configure(); config = getConfig(); provider = createProvider(config); continue; }
 
+    if (cmd === '/init') {
+      const bimmoRcPath = path.join(process.cwd(), '.bimmorc.json');
+      if (fs.existsSync(bimmoRcPath)) {
+        const { overwrite } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'overwrite',
+          message: 'O arquivo .bimmorc.json já existe. Deseja sobrescrever?',
+          default: false
+        }]);
+        if (!overwrite) continue;
+      }
+      const initialConfig = {
+        projectName: path.basename(process.cwd()),
+        rules: ["Siga as convenções existentes.", "Prefira código modular."],
+        preferredTech: [],
+        ignorePatterns: ["node_modules", ".git"]
+      };
+      fs.writeFileSync(bimmoRcPath, JSON.stringify(initialConfig, null, 2));
+      console.log(green(`\n✅ .bimmorc.json criado com sucesso.\n`));
+      
+      resetMessages();
+      continue;
+    }
+
     if (cmd === '/swarm') {
       const agents = config.agents || {};
       const agentList = Object.keys(agents);
-
       if (agentList.length < 2) {
-        console.log(chalk.yellow('\nVocê precisa de pelo menos 2 Agentes configurados para rodar um Enxame.\nUse /config para criar Agentes.\n'));
+        console.log(chalk.yellow('\nCrie pelo menos 2 Agentes em /config primeiro.\n'));
         continue;
       }
-
       const { swarmAction } = await inquirer.prompt([{
         type: 'list',
         name: 'swarmAction',
-        message: 'Ação de Enxame:',
-        choices: ['Rodar Enxame Sequencial', 'Rodar Enxame Hierárquico', 'Voltar']
+        message: 'Tipo de Enxame:',
+        choices: ['Sequencial (A → B)', 'Hierárquico (Líder + Workers)', 'Voltar']
       }]);
-
       if (swarmAction === 'Voltar') continue;
-
-      const { goal } = await inquirer.prompt([{ type: 'input', name: 'goal', message: 'Qual o objetivo final deste enxame?' }]);
-
-      if (swarmAction === 'Rodar Enxame Sequencial') {
-        const { selectedAgents } = await inquirer.prompt([{
-          type: 'checkbox',
-          name: 'selectedAgents',
-          message: 'Selecione os agentes e a ordem (mínimo 2):',
-          choices: agentList
-        }]);
-
-        if (selectedAgents.length < 2) {
-          console.log(chalk.red('\nSelecione pelo menos 2 agentes.\n'));
-          continue;
-        }
-
-        try {
-          const finalResult = await orchestrator.runSequential(selectedAgents, goal);
-          console.log(lavender('\n=== RESULTADO FINAL DO ENXAME ===\n'));
-          console.log(marked(finalResult));
-        } catch (e) {
-          console.error(chalk.red(`\nErro no Enxame: ${e.message}`));
-        }
-      }
-
-      if (swarmAction === 'Rodar Enxame Hierárquico') {
-        const { manager } = await inquirer.prompt([{ type: 'list', name: 'manager', message: 'Selecione o Agente Líder (Manager):', choices: agentList }]);
-        const { workers } = await inquirer.prompt([{ type: 'checkbox', name: 'workers', message: 'Selecione os Workers:', choices: agentList.filter(a => a !== manager) }]);
-
-        try {
-          const finalResult = await orchestrator.runHierarchical(manager, workers, goal);
-          console.log(lavender('\n=== RESULTADO FINAL DO ENXAME ===\n'));
-          console.log(marked(finalResult));
-        } catch (e) {
-          console.error(chalk.red(`\nErro no Enxame: ${e.message}`));
+      const { goal } = await inquirer.prompt([{ type: 'input', name: 'goal', message: 'Objetivo do enxame:' }]);
+      
+      try {
+        let result;
+        if (swarmAction.includes('Sequencial')) {
+          const { selectedAgents } = await inquirer.prompt([{ type: 'checkbox', name: 'selectedAgents', message: 'Ordem dos agentes:', choices: agentList }]);
+          result = await orchestrator.runSequential(selectedAgents, goal);
+        } else {
+          const { manager } = await inquirer.prompt([{ type: 'list', name: 'manager', message: 'Líder:', choices: agentList }]);
+          const { workers } = await inquirer.prompt([{ type: 'checkbox', name: 'workers', message: 'Workers:', choices: agentList.filter(a => a !== manager) }]);
+          result = await orchestrator.runHierarchical(manager, workers, goal);
         }
+        console.log(lavender('\n=== RESULTADO FINAL ===\n') + marked(result));
+      } catch (e) {
+        console.error(chalk.red(`\nErro: ${e.message}`));
       }
       continue;
     }
@@ -264,14 +334,13 @@ Comandos Disponíveis:
     if (rawInput === '') continue;
 
     const controller = new AbortController();
-    const interruptHandler = () => controller.abort();
-    const keypressHandler = (str, key) => { if (key.name === 'escape' || (key.ctrl && key.name === 'c')) interruptHandler(); };
-    process.on('SIGINT', interruptHandler);
-    process.stdin.on('keypress', keypressHandler);
+    const localInterruptHandler = () => controller.abort();
+    process.removeAllListeners('SIGINT');
+    process.on('SIGINT', localInterruptHandler);
 
     let modeInstr = "";
-    if (currentMode === 'plan') modeInstr = "\n[MODO PLAN] Descreva e analise, mas NÃO altere arquivos.";
-    else if (currentMode === 'edit') modeInstr = "\n[MODO EDIT] Você tem permissão para usar write_file e run_command AGORA.";
+    if (currentMode === 'plan') modeInstr = "\n[MODO PLAN] Apenas analise.";
+    else if (currentMode === 'edit') modeInstr = `\n[MODO EDIT] Você tem permissão para usar ferramentas. (Auto-Accept: ${editState.autoAccept ? 'ON' : 'OFF'})`;
 
     const content = await processInput(rawInput);
     messages.push({ 
@@ -280,7 +349,7 @@ Comandos Disponíveis:
     });
 
     const spinner = ora({
-      text: lavender(`bimmo (${currentMode}) pensando... (Ctrl+C para interromper)`),
+      text: lavender(`bimmo pensando... (Ctrl+C para interromper)`),
       color: currentMode === 'edit' ? 'red' : 'magenta'
     }).start();
 
@@ -296,14 +365,24 @@ Comandos Disponíveis:
     } catch (err) {
       spinner.stop();
       if (controller.signal.aborted || err.name === 'AbortError') {
-        console.log(yellow('\n\n⚠️  Operação interrompida pelo usuário.\n'));
+        console.log(yellow('\n\n⚠️  Interrompido.\n'));
         messages.pop();
       } else {
-        console.error(chalk.red('\n✖ Erro Crítico:') + ' ' + err.message + '\n');
+        console.error(chalk.red('\n✖ Erro:') + ' ' + err.message + '\n');
       }
     } finally {
-      process.off('SIGINT', interruptHandler);
-      process.stdin.off('keypress', keypressHandler);
+      process.removeListener('SIGINT', localInterruptHandler);
+      process.on('SIGINT', () => {
+        exitCounter++;
+        if (exitCounter === 1) {
+          console.log(gray('\n(Pressione Ctrl+C novamente para sair)'));
+          if (exitTimer) clearTimeout(exitTimer);
+          exitTimer = setTimeout(() => { exitCounter = 0; }, 2000);
+        } else {
+          console.log(lavender('\n👋 BIMMO encerrando sessão. Até logo!\n'));
+          process.exit(0);
+        }
+      });
     }
   }
-}
+}

package/src/providers/grok.js

@@ -13,24 +13,23 @@ export class GrokProvider extends BaseProvider {
 
   formatMessages(messages) {
     return messages.map(msg => {
-      if (typeof msg.content === 'string') {
+      if (typeof msg.content === 'string' || msg.content === null) {
         return msg;
       }
       
-      const content = msg.content.map(part => {
-        if (part.type === 'text') {
-          return { type: 'text', text: part.text };
-        } else if (part.type === 'image') {
-          return {
+      if (Array.isArray(msg.content)) {
+        const content = msg.content.map(part => {
+          if (part.type === 'text') return { type: 'text', text: part.text };
+          if (part.type === 'image') return {
             type: 'image_url',
-            image_url: {
-              url: `data:${part.mimeType};base64,${part.data}`
-            }
+            image_url: { url: `data:${part.mimeType};base64,${part.data}` }
           };
-        }
-      });
+          return part;
+        });
+        return { ...msg, content };
+      }
 
-      return { ...msg, content };
+      return msg;
     });
   }
 

package/src/providers/openai.js

@@ -21,16 +21,25 @@ export class OpenAIProvider extends BaseProvider {
 
   formatMessages(messages) {
     return messages.map(msg => {
-      if (typeof msg.content === 'string') return msg;
+      // Se content for string ou null (comum em tool calls), retorna como está
+      if (typeof msg.content === 'string' || msg.content === null) {
+        return msg;
+      }
       
-      const content = msg.content.map(part => {
-        if (part.type === 'text') return { type: 'text', text: part.text };
-        if (part.type === 'image') return {
-          type: 'image_url',
-          image_url: { url: `data:${part.mimeType};base64,${part.data}` }
-        };
-      });
-      return { ...msg, content };
+      // Se for um array (multimodal), processa as partes
+      if (Array.isArray(msg.content)) {
+        const content = msg.content.map(part => {
+          if (part.type === 'text') return { type: 'text', text: part.text };
+          if (part.type === 'image') return {
+            type: 'image_url',
+            image_url: { url: `data:${part.mimeType};base64,${part.data}` }
+          };
+          return part; // Mantém outras partes (como tool_result se houver)
+        });
+        return { ...msg, content };
+      }
+
+      return msg;
     });
   }