bimmo-cli 1.2.3 → 2.0.1

package/bin/bimmo

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// Silencia o aviso de depreciação do punycode que polui o terminal em versões novas do Node
+process.removeAllListeners('warning');
+
 import { program } from 'commander';
 import { startInteractive } from '../src/interface.js';
 import { configure } from '../src/config.js';
@@ -7,13 +10,13 @@ import { configure } from '../src/config.js';
 program
   .name('bimmo')
   .description('bimmo — Sua IA universal no terminal (verde & lavanda)')
-  .version('1.1.0');
+  .version('1.2.4');
 
 program
   .command('config')
   .description('Configurar provedor e chave de API')
   .action(configure);
 
-program.action(startInteractive); // ao digitar só "bimmo" entra no chat
+program.action(startInteractive);
 
-program.parse();
+program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bimmo-cli",
-  "version": "1.2.3",
-  "description": "🌿 CLI universal para IAs com interface verde/lavanda, modo agente (Auto-Edit) e contexto inteligente de projeto.",
+  "version": "2.0.1",
+  "description": "🌿 Plataforma de Orquestração de Agentes IA (Swarms) com interface verde/lavanda, modo Auto-Edit e contexto 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,
@@ -109,9 +111,9 @@ export async function startInteractive() {
   }
 
   let provider = createProvider(config);
+  const orchestrator = new SwarmOrchestrator(config);
   const messages = [];
 
-  // 1. Injeta o sistema de contexto inteligente do projeto
   const projectContext = getProjectContext();
   messages.push({ 
     role: 'system', 
@@ -123,11 +125,14 @@ export async function startInteractive() {
   console.log(lavender('─'.repeat(60)));
   console.log(green(`   Perfil Ativo: ${bold(config.activeProfile || 'Padrão')} (${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 | /switch [perfil] | /model [novo] | /help'));
   console.log(lavender('─'.repeat(60)) + '\n');
 
   console.log(lavender('👋 Olá! Sou seu agente BIMMO. No que posso atuar?\n'));
 
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
   while (true) {
     const modeIndicator = getModeStyle();
     const { input } = await inquirer.prompt([
@@ -144,19 +149,18 @@ export async function startInteractive() {
 
     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
+        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 {
@@ -165,7 +169,6 @@ export async function startInteractive() {
       continue;
     }
 
-    // /model [modelo] -> Troca apenas o modelo do Perfil atual
     if (cmd.startsWith('/model ')) {
       const newModel = rawInput.split(' ')[1];
       if (newModel) {
@@ -189,56 +192,83 @@ export async function startInteractive() {
       console.log(gray(`
 Comandos Disponíveis:
   /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)
+  /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
+  /init            → Inicializar .bimmorc.json
   @caminho         → Anexar arquivos ou imagens
       `));
       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 (cmd === '/config') { await configure(); config = getConfig(); provider = createProvider(config); 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'));
+        continue;
+      }
+
+      const { swarmAction } = await inquirer.prompt([{
+        type: 'list',
+        name: 'swarmAction',
+        message: 'Ação de Enxame:',
+        choices: ['Rodar Enxame Sequencial', 'Rodar Enxame Hierárquico', '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 (!overwrite) continue;
+
+        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}`));
+        }
       }
 
-      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`));
-      
-      // Recarrega o contexto para a conversa atual
-      messages.push({ 
-        role: 'system', 
-        content: `Novo contexto inicializado via /init:\n${JSON.stringify(initialConfig, null, 2)}` 
-      });
+      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}`));
+        }
+      }
       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();
+    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);
+
     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.";
@@ -250,22 +280,30 @@ Comandos Disponíveis:
     });
 
     const spinner = ora({
-      text: lavender(`bimmo (${currentMode}) pensando...`),
+      text: lavender(`bimmo (${currentMode}) 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 Crítico:') + ' ' + err.message + '\n');
+      }
+    } finally {
+      process.off('SIGINT', interruptHandler);
+      process.stdin.off('keypress', keypressHandler);
     }
   }
 }

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;
   }
-}
+}