bimmo-cli 1.2.4 → 2.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bimmo-cli",
-  "version": "1.2.4",
-  "description": "🌿 CLI universal para IAs com interface verde/lavanda, modo agente (Auto-Edit) e contexto inteligente de projeto.",
+  "version": "2.0.3",
+  "description": "🌿 Plataforma de IA universal com modo Normal, Agentes Especialistas e Enxames (Swarms). Suporte a Auto-Edit, Contexto Inteligente e interrupção inteligente.",
   "bin": {
     "bimmo": "bin/bimmo"
   },
@@ -15,7 +15,10 @@
     "grok",
     "deepseek",
     "openrouter",
+    "zai",
     "agent",
+    "swarm",
+    "orchestration",
     "multimodal",
     "terminal"
   ],

package/src/config.js

@@ -29,6 +29,7 @@ export async function configure() {
       choices: [
         { name: 'Criar novo perfil de IA', value: 'create' },
         { name: 'Selecionar perfil ativo', value: 'select' },
+        { name: 'Gerenciar Agentes Especialistas', value: 'agents' },
         { name: 'Configurar chave Tavily', value: 'tavily' },
         { name: 'Sair', value: 'exit' }
       ]
@@ -37,6 +38,8 @@ export async function configure() {
 
   if (action === 'exit') return;
 
+  if (action === 'agents') return configureAgents();
+
   if (action === 'tavily') {
     const { tavilyKey } = await inquirer.prompt([{
       type: 'input',
@@ -74,7 +77,7 @@ export async function configure() {
     {
       type: 'input',
       name: 'profileName',
-      message: 'Dê um nome para este perfil (ex: MeuGPT, ClaudeTrabalho):',
+      message: 'Dê um nome para este perfil:',
       validate: i => i.length > 0 || 'Nome obrigatório'
     },
     {
@@ -120,6 +123,50 @@ export async function configure() {
   console.log(chalk.green(`\n✅ Perfil "${answers.profileName}" criado e ativado!`));
 }
 
+async function configureAgents() {
+  const agents = config.get('agents') || {};
+  const profiles = config.get('profiles') || {};
+  const profileList = Object.keys(profiles);
+
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: 'Gerenciar Agentes:',
+    choices: ['Criar Agente', 'Listar Agentes', 'Remover Agente', 'Voltar']
+  }]);
+
+  if (action === 'Voltar') return configure();
+
+  if (action === 'Criar Agente') {
+    if (profileList.length === 0) {
+      console.log(chalk.red('Crie um perfil de IA primeiro.'));
+      return configure();
+    }
+
+    const answers = await inquirer.prompt([
+      { type: 'input', name: 'name', message: 'Nome do Agente (ex: Arquiteto, Revisor):' },
+      { type: 'list', name: 'profile', message: 'Qual perfil este agente usará?', choices: profileList },
+      { type: 'input', name: 'modelOverride', message: 'Sobrescrever modelo (vazio para manter o do perfil):' },
+      { type: 'list', name: 'mode', message: 'Modo padrão:', choices: ['chat', 'plan', 'edit'] },
+      { type: 'editor', name: 'role', message: 'Descreva a Task/Papel deste agente (System Prompt):' }
+    ]);
+
+    agents[answers.name] = answers;
+    config.set('agents', agents);
+    console.log(chalk.green(`✓ Agente "${answers.name}" criado!`));
+  }
+
+  if (action === 'Listar Agentes') {
+    console.log(chalk.blue('\nAgentes Configurados:'));
+    Object.keys(agents).forEach(name => {
+      console.log(`- ${chalk.bold(name)} [${agents[name].profile}] (Modo: ${agents[name].mode})`);
+    });
+    console.log('');
+  }
+
+  return configureAgents();
+}
+
 export function getConfig() {
   return config.store;
 }

package/src/interface.js

@@ -7,10 +7,12 @@ import ora from 'ora';
 import fs from 'fs';
 import path from 'path';
 import mime from 'mime-types';
+import readline from 'readline';
 
 import { getConfig, configure, updateActiveModel, switchProfile } from './config.js';
 import { createProvider } from './providers/factory.js';
 import { getProjectContext } from './project-context.js';
+import { SwarmOrchestrator } from './orchestrator.js';
 
 marked.use(new TerminalRenderer({
   heading: chalk.hex('#c084fc').bold,
@@ -23,7 +25,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(' ');
@@ -91,10 +96,11 @@ 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': return chalk.red.bold(`${personaLabel}[EDIT] `);
+    default: return lavender.bold(`${personaLabel}[CHAT] `);
   }
 }
 
@@ -109,77 +115,120 @@ export async function startInteractive() {
   }
 
   let provider = createProvider(config);
-  const messages = [];
+  const orchestrator = new SwarmOrchestrator(config);
+  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}` });
+      }
+    }
+  };
 
-  // 1. Injeta o sistema de contexto inteligente do projeto
-  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 | /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'));
+
+  // Handler Global de SIGINT para o modo ocioso (Idle)
+  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) {
+      // Inquirer joga erro no Ctrl+C se não for tratado
+      continue;
+    }
 
     const rawInput = input.trim();
     const cmd = rawInput.toLowerCase();
 
     if (cmd === '/exit' || cmd === 'exit' || cmd === 'sair') {
       console.log(lavender('\n👋 BIMMO encerrando sessão. Até logo!\n'));
-      break;
+      process.exit(0);
     }
 
     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; }
 
-    // /switch [perfil] -> Troca Perfil + Chave + Provedor + Modelo instantaneamente
     if (cmd.startsWith('/switch ')) {
       const profileName = rawInput.split(' ')[1];
       if (profileName && switchProfile(profileName)) {
-        config = getConfig(); // Atualiza config local
-        provider = createProvider(config); // Recria provedor com nova chave/url
-        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`));
+        config = getConfig();
+        provider = createProvider(config);
+        console.log(green(`\n✓ Perfil "${bold(profileName)}" ativado!`));
+        continue;
       }
+      console.log(chalk.red(`\n✖ Perfil não encontrado.\n`));
       continue;
     }
 
-    // /model [modelo] -> Troca apenas o modelo do Perfil atual
-    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;
@@ -187,61 +236,73 @@ export async function startInteractive() {
 
     if (cmd === '/help') {
       console.log(gray(`
-Comandos Disponíveis:
+Comandos de Modo:
   /chat /plan /edit → Mudar modo de operação
-  /switch [nome]   → Mudar PERFIL (Troca Chave/API/IA completa)
-  /model [nome]    → Mudar apenas o MODELO da IA atual
-  /init            → Inicializar .bimmorc.json neste projeto
-  /config          → Gerenciar perfis e chaves
-  /clear           → Resetar conversa (mantém contexto base)
-  @caminho         → Anexar arquivos ou imagens
+  /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
+  @arquivo         → Ler arquivo ou imagem
       `));
       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;
-      }
+    if (cmd === '/config') { await configure(); config = getConfig(); provider = createProvider(config); continue; }
 
-      const initialConfig = {
-        projectName: path.basename(process.cwd()),
-        rules: [
-          "Siga as convenções de código existentes.",
-          "Prefira código limpo e modular.",
-          "Sempre valide mudanças antes de aplicar no modo EDIT."
-        ],
-        preferredTech: [],
-        architecture: "Não especificada",
-        ignorePatterns: ["node_modules", "dist", ".git"]
-      };
-
-      fs.writeFileSync(bimmoRcPath, JSON.stringify(initialConfig, null, 2));
-      console.log(green(`\n✅ Arquivo .bimmorc.json criado com sucesso em: ${bold(bimmoRcPath)}\n`));
+    if (cmd === '/swarm') {
+      const agents = config.agents || {};
+      const agentList = Object.keys(agents);
+      if (agentList.length < 2) {
+        console.log(chalk.yellow('\nCrie pelo menos 2 Agentes em /config primeiro.\n'));
+        continue;
+      }
+      const { swarmAction } = await inquirer.prompt([{
+        type: 'list',
+        name: 'swarmAction',
+        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: 'Objetivo do enxame:' }]);
       
-      // Recarrega o contexto para a conversa atual
-      messages.push({ 
-        role: 'system', 
-        content: `Novo contexto inicializado via /init:\n${JSON.stringify(initialConfig, null, 2)}` 
-      });
+      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;
     }
 
-    if (cmd === '/config') { await configure(); config = getConfig(); provider = createProvider(config); continue; }
-
     if (rawInput === '') continue;
 
-    // Injeção dinâmica de instruções de modo
+    const controller = new AbortController();
+    
+    // Handler local para SIGINT durante o processamento da IA
+    const localInterruptHandler = () => {
+      controller.abort();
+    };
+
+    // Remove temporariamente o handler global de saída
+    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] Aplique as mudanças agora.";
 
     const content = await processInput(rawInput);
     messages.push({ 
@@ -250,22 +311,41 @@ Comandos Disponíveis:
     });
 
     const spinner = ora({
-      text: lavender(`bimmo (${currentMode}) pensando...`),
+      text: lavender(`bimmo pensando... (Ctrl+C para interromper)`),
       color: currentMode === 'edit' ? 'red' : 'magenta'
     }).start();
 
     try {
-      const responseText = await provider.sendMessage(messages);
+      let responseText = await provider.sendMessage(messages, { signal: controller.signal });
       spinner.stop();
+      const cleanedText = responseText.replace(/<\/?[^>]+(>|$)/g, "");
       messages.push({ role: 'assistant', content: responseText });
-
       console.log('\n' + lavender('bimmo') + getModeStyle());
       console.log(lavender('─'.repeat(50)));
-      console.log(marked(responseText));
+      console.log(marked(cleanedText));
       console.log(gray('─'.repeat(50)) + '\n');
     } catch (err) {
       spinner.stop();
-      console.error(chalk.red('✖ Erro Crítico:') + ' ' + err.message + '\n');
+      if (controller.signal.aborted || err.name === 'AbortError') {
+        console.log(yellow('\n\n⚠️  Operação interrompida pelo usuário.\n'));
+        messages.pop();
+      } else {
+        console.error(chalk.red('\n✖ Erro:') + ' ' + err.message + '\n');
+      }
+    } finally {
+      // Restaura o handler global de saída
+      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/orchestrator.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createProvider } from './providers/factory.js';
+import { getProjectContext } from './project-context.js';
+
+export class SwarmOrchestrator {
+  constructor(config) {
+    this.config = config;
+    this.agents = config.agents || {};
+    this.profiles = config.profiles || {};
+  }
+
+  /**
+   * Executa uma tarefa sequencialmente através de uma lista de agentes.
+   * O output de um agente vira o contexto do próximo.
+   */
+  async runSequential(agentNames, goal, options = {}) {
+    let currentContext = goal;
+    const results = [];
+
+    console.log(chalk.cyan(`\n🚀 Iniciando Enxame Sequencial: ${agentNames.join(' → ')}\n`));
+
+    for (const name of agentNames) {
+      const agent = this.agents[name];
+      if (!agent) throw new Error(`Agente ${name} não encontrado.`);
+
+      const profile = this.profiles[agent.profile];
+      if (!profile) throw new Error(`Perfil ${agent.profile} do agente ${name} não encontrado.`);
+
+      const agentConfig = {
+        ...profile,
+        model: agent.modelOverride || profile.model
+      };
+
+      const provider = createProvider(agentConfig);
+      const spinner = ora({
+        text: chalk.magenta(`Agente [${name}] trabalhando...`),
+        color: agent.mode === 'edit' ? 'red' : 'magenta'
+      }).start();
+
+      const messages = [
+        { role: 'system', content: `Você é o agente ${name}. Sua tarefa específica é: ${agent.role}\n\nMODO ATUAL: ${agent.mode.toUpperCase()}\n${getProjectContext()}` },
+        { role: 'user', content: `CONTEXTO ATUAL:\n${currentContext}\n\nOBJETIVO DO ENXAME:\n${goal}\n\nPor favor, execute sua parte e retorne o resultado final processado.` }
+      ];
+
+      try {
+        const response = await provider.sendMessage(messages, { signal: options.signal });
+        spinner.succeed(chalk.green(`Agente [${name}] concluído.`));
+        
+        currentContext = response;
+        results.push({ agent: name, output: response });
+      } catch (err) {
+        spinner.fail(chalk.red(`Agente [${name}] falhou: ${err.message}`));
+        throw err;
+      }
+    }
+
+    return currentContext;
+  }
+
+  /**
+   * Executa uma tarefa hierárquica.
+   * Um Manager recebe o objetivo, define o que cada Worker deve fazer, e consolida.
+   */
+  async runHierarchical(managerName, workerNames, goal, options = {}) {
+    console.log(chalk.cyan(`\n👑 Iniciando Enxame Hierárquico (Líder: ${managerName})\n`));
+
+    // Passo 1: Manager analisa e delega
+    const managerOutput = await this.runSequential([managerName], `Analise o objetivo abaixo e descreva o que cada um dos seguintes agentes deve fazer: ${workerNames.join(', ')}.\n\nOBJETIVO: ${goal}`);
+
+    // Passo 2: Workers executam baseado na delegação do Manager (em paralelo para velocidade)
+    console.log(chalk.blue(`\n👷 Workers entrando em ação...\n`));
+    const workerPromises = workerNames.map(name => 
+      this.runSequential([name], `Baseado no plano do Manager:\n${managerOutput}\n\nExecute sua tarefa para o objetivo: ${goal}`, options)
+    );
+
+    const workerResults = await Promise.all(workerPromises);
+
+    // Passo 3: Manager consolida tudo
+    const finalResult = await this.runSequential([managerName], `Aqui estão os resultados dos workers:\n${workerResults.join('\n---\n')}\n\nPor favor, consolide tudo em um resultado final perfeito para o objetivo: ${goal}`, options);
+
+    return finalResult;
+  }
+}

package/src/providers/anthropic.js

@@ -21,7 +21,7 @@ export class AnthropicProvider extends BaseProvider {
     });
   }
 
-  async sendMessage(messages) {
+  async sendMessage(messages, options = {}) {
     const systemMessage = messages.find(m => m.role === 'system');
     const userMessages = messages
       .filter(m => m.role !== 'system')
@@ -30,7 +30,6 @@ export class AnthropicProvider extends BaseProvider {
         content: this.formatContent(m.content)
       }));
 
-    // Converte tools do agent.js para o formato da Anthropic
     const anthropicTools = tools.map(t => ({
       name: t.name,
       description: t.description,
@@ -44,17 +43,18 @@ export class AnthropicProvider extends BaseProvider {
       messages: userMessages,
       tools: anthropicTools,
       temperature: 0.7
-    });
+    }, { signal: options.signal });
 
     if (response.stop_reason === 'tool_use') {
       const toolUse = response.content.find(p => p.type === 'tool_use');
       const tool = tools.find(t => t.name === toolUse.name);
       
       if (tool) {
+        if (options.signal?.aborted) throw new Error('Abortado pelo usuário');
+        
         console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
         const result = await tool.execute(toolUse.input);
         
-        // Adiciona a resposta da IA e o resultado da tool ao histórico
         const nextMessages = [
           ...messages,
           { role: 'assistant', content: response.content },
@@ -68,10 +68,10 @@ export class AnthropicProvider extends BaseProvider {
           }
         ];
         
-        return this.sendMessage(nextMessages);
+        return this.sendMessage(nextMessages, options);
       }
     }
 
     return response.content[0].text;
   }
-}
+}

package/src/providers/base.js

@@ -3,7 +3,7 @@ export class BaseProvider {
     this.config = config;
   }
 
-  async sendMessage(messages) {
+  async sendMessage(messages, options = {}) {
     throw new Error('Método sendMessage deve ser implementado');
   }
-}
+}

package/src/providers/gemini.js

@@ -18,7 +18,7 @@ export class GeminiProvider extends BaseProvider {
     });
   }
 
-  async sendMessage(messages) {
+  async sendMessage(messages, options = {}) {
     const systemPrompt = messages.find(m => m.role === 'system')?.content;
     const history = messages
       .filter(m => m.role !== 'system')
@@ -30,7 +30,6 @@ export class GeminiProvider extends BaseProvider {
 
     const lastMessageContent = this.formatContent(messages[messages.length - 1].content);
 
-    // Converte tools do agent.js para o formato do Gemini
     const geminiTools = tools.map(t => ({
       functionDeclarations: [{
         name: t.name,
@@ -53,19 +52,19 @@ export class GeminiProvider extends BaseProvider {
     const result = await chat.sendMessage(lastMessageContent);
     const response = await result.response;
     
-    // Processamento de Tool Calls no Gemini
     const call = response.candidates[0].content.parts.find(p => p.functionCall);
     if (call) {
+      if (options.signal?.aborted) throw new Error('Abortado pelo usuário');
+      
       const tool = tools.find(t => t.name === call.functionCall.name);
       if (tool) {
         console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
-        const result = await tool.execute(call.functionCall.args);
+        const toolResult = await tool.execute(call.functionCall.args);
         
-        // No Gemini, enviamos o resultado de volta para o chat
         const resultResponse = await chat.sendMessage([{
           functionResponse: {
             name: call.functionCall.name,
-            response: { content: result }
+            response: { content: toolResult }
           }
         }]);
         return resultResponse.response.text();
@@ -74,4 +73,4 @@ export class GeminiProvider extends BaseProvider {
 
     return response.text();
   }
-}
+}

package/src/providers/grok.js

@@ -1,5 +1,6 @@
 import OpenAI from 'openai';
 import { BaseProvider } from './base.js';
+import { tools } from '../agent.js';
 
 export class GrokProvider extends BaseProvider {
   constructor(config) {
@@ -33,15 +34,15 @@ export class GrokProvider extends BaseProvider {
     });
   }
 
-  async sendMessage(messages) {
+  async sendMessage(messages, options = {}) {
     const formattedMessages = this.formatMessages(messages);
     
     const response = await this.client.chat.completions.create({
       model: this.config.model,
       messages: formattedMessages,
       temperature: 0.7
-    });
+    }, { signal: options.signal });
 
     return response.choices[0].message.content;
   }
-}
+}

package/src/providers/ollama.js

@@ -13,7 +13,7 @@ export class OllamaProvider extends BaseProvider {
 
       const images = msg.content
         .filter(part => part.type === 'image')
-        .map(part => part.data); // Ollama espera apenas a string base64
+        .map(part => part.data);
 
       const text = msg.content
         .filter(part => part.type === 'text')
@@ -28,7 +28,7 @@ export class OllamaProvider extends BaseProvider {
     });
   }
 
-  async sendMessage(messages) {
+  async sendMessage(messages, options = {}) {
     const formattedMessages = this.formatMessages(messages);
 
     const response = await this.client.chat({
@@ -38,7 +38,7 @@ export class OllamaProvider extends BaseProvider {
       options: {
         temperature: 0.7,
       }
-    });
+    }, { signal: options.signal });
 
     const text = response.message?.content;
 
@@ -48,4 +48,4 @@ export class OllamaProvider extends BaseProvider {
 
     return text;
   }
-}
+}

package/src/providers/openai.js

@@ -34,7 +34,7 @@ export class OpenAIProvider extends BaseProvider {
     });
   }
 
-  async sendMessage(messages) {
+  async sendMessage(messages, options = {}) {
     const formattedMessages = this.formatMessages(messages);
     
     const openAiTools = tools.map(t => ({
@@ -46,25 +46,26 @@ export class OpenAIProvider extends BaseProvider {
       }
     }));
 
-    const options = {
+    const requestOptions = {
       model: this.config.model,
       messages: formattedMessages,
       temperature: 0.7
     };
 
-    // Só envia tools se houver alguma definida para evitar erros em alguns provedores
     if (openAiTools.length > 0) {
-      options.tools = openAiTools;
-      options.tool_choice = 'auto';
+      requestOptions.tools = openAiTools;
+      requestOptions.tool_choice = 'auto';
     }
 
-    const response = await this.client.chat.completions.create(options);
+    const response = await this.client.chat.completions.create(requestOptions, { signal: options.signal });
 
     const message = response.choices[0].message;
 
     if (message.tool_calls) {
       const toolResults = [];
       for (const toolCall of message.tool_calls) {
+        if (options.signal?.aborted) throw new Error('Abortado pelo usuário');
+        
         const tool = tools.find(t => t.name === toolCall.function.name);
         if (tool) {
           console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
@@ -80,9 +81,9 @@ export class OpenAIProvider extends BaseProvider {
       }
 
       const nextMessages = [...formattedMessages, message, ...toolResults];
-      return this.sendMessage(nextMessages);
+      return this.sendMessage(nextMessages, options);
     }
 
     return message.content;
   }
-}
+}