plazbot-cli 0.2.26 → 0.3.2

package/src/commands/agent/templates.ts

@@ -1,11 +1,12 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { theme, section, kvPair, createTable, createSpinner } from '../../utils/ui';
-import { AgentCommandOptions } from '../../types/agent';
-import { connectChannelFlow, WizardContext } from './wizard';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { theme, section, kvPair, createTable, createSpinner } from '../../utils/ui.js';
+import { AgentCommandOptions } from '../../types/agent.js';
+import { connectChannelFlow, WizardContext } from './wizard.js';
 
 interface TemplatePlaceholder {
   key: string;
@@ -594,57 +595,57 @@ const plantillaVentas: any = {
 // Registro de plantillas con sus placeholders
 const TEMPLATES: Template[] = [
   {
-    name: 'Asistente de Ventas',
-    description: 'Agente para gestion comercial, cotizaciones y pedidos',
-    industry: 'Ventas',
+    name: 'Sales Assistant',
+    description: 'Agent for sales management, quotes and orders',
+    industry: 'Sales',
     placeholders: [
-      { key: '[NOMBRE DE LA EMPRESA]', label: 'Nombre de tu empresa' },
-      { key: '[DIRECCION COMPLETA]', label: 'Direccion de tu empresa' },
-      { key: '[NUMERO DE TELEFONO]', label: 'Telefono de contacto' },
+      { key: '[NOMBRE DE LA EMPRESA]', label: 'Your company name' },
+      { key: '[DIRECCION COMPLETA]', label: 'Your company address' },
+      { key: '[NUMERO DE TELEFONO]', label: 'Contact phone' },
     ],
     config: plantillaVentas,
   },
   {
-    name: 'Soporte Tecnico IT',
-    description: 'Agente para soporte tecnico, tickets y resolucion de problemas',
-    industry: 'Tecnologia',
+    name: 'IT Technical Support',
+    description: 'Agent for technical support, tickets and problem resolution',
+    industry: 'Technology',
     placeholders: [
-      { key: '[NOMBRE DE LA EMPRESA]', label: 'Nombre de tu empresa' },
-      { key: '[NUMERO DE TELEFONO]', label: 'Telefono de soporte' },
-      { key: '[EMAIL DE SOPORTE]', label: 'Email de soporte (ej: soporte@empresa.com)' },
+      { key: '[NOMBRE DE LA EMPRESA]', label: 'Your company name' },
+      { key: '[NUMERO DE TELEFONO]', label: 'Support phone' },
+      { key: '[EMAIL DE SOPORTE]', label: 'Support email (e.g. support@company.com)' },
     ],
     config: plantillaSoporteIT,
   },
   {
-    name: 'Asistente de Clinica',
-    description: 'Agente para clinicas: citas medicas, horarios y especialidades',
-    industry: 'Salud',
+    name: 'Clinic Assistant',
+    description: 'Agent for clinics: medical appointments, schedules and specialties',
+    industry: 'Health',
     placeholders: [
-      { key: '[NOMBRE DE LA CLINICA]', label: 'Nombre de tu clinica' },
-      { key: '[DIRECCION COMPLETA]', label: 'Direccion de la clinica' },
-      { key: '[NUMERO DE TELEFONO]', label: 'Telefono de la clinica' },
+      { key: '[NOMBRE DE LA CLINICA]', label: 'Your clinic name' },
+      { key: '[DIRECCION COMPLETA]', label: 'Clinic address' },
+      { key: '[NUMERO DE TELEFONO]', label: 'Clinic phone' },
     ],
     config: plantillaClinica,
   },
   {
-    name: 'Asistente de Restaurante',
-    description: 'Agente para restaurantes: reservas, menu y delivery',
-    industry: 'Gastronomia',
+    name: 'Restaurant Assistant',
+    description: 'Agent for restaurants: reservations, menu and delivery',
+    industry: 'Gastronomy',
     placeholders: [
-      { key: '[NOMBRE DEL RESTAURANTE]', label: 'Nombre de tu restaurante' },
-      { key: '[DIRECCION COMPLETA]', label: 'Direccion del restaurante' },
-      { key: '[NUMERO DE TELEFONO]', label: 'Telefono del restaurante' },
+      { key: '[NOMBRE DEL RESTAURANTE]', label: 'Your restaurant name' },
+      { key: '[DIRECCION COMPLETA]', label: 'Restaurant address' },
+      { key: '[NUMERO DE TELEFONO]', label: 'Restaurant phone' },
     ],
     config: plantillaRestaurante,
   },
   {
-    name: 'Asistente Inmobiliario',
-    description: 'Agente para inmobiliarias: propiedades, visitas y asesoria',
-    industry: 'Inmobiliario',
+    name: 'Real Estate Assistant',
+    description: 'Agent for real estate: properties, viewings and advisory',
+    industry: 'Real Estate',
     placeholders: [
-      { key: '[NOMBRE DE LA INMOBILIARIA]', label: 'Nombre de tu inmobiliaria' },
-      { key: '[DIRECCION COMPLETA]', label: 'Direccion de la oficina' },
-      { key: '[NUMERO DE TELEFONO]', label: 'Telefono de contacto' },
+      { key: '[NOMBRE DE LA INMOBILIARIA]', label: 'Your real estate name' },
+      { key: '[DIRECCION COMPLETA]', label: 'Office address' },
+      { key: '[NUMERO DE TELEFONO]', label: 'Contact phone' },
     ],
     config: plantillaInmobiliario,
   },
@@ -675,13 +676,13 @@ function replacePlaceholders(obj: any, replacements: Record<string, string>): an
 }
 
 export const templatesCommand = new Command('templates')
-  .description('Crear un agente desde plantillas pre-configuradas')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
-  .option('--json', 'Solo mostrar el JSON resultante sin crear el agente', false)
+  .description('Create an agent from pre-configured templates')
+  .option('--dev', 'Use development environment', false)
+  .option('--json', 'Only show the resulting JSON without creating the agent', false)
   .action(async (options: AgentCommandOptions & { json?: boolean }) => {
     try {
-      console.log(section('Plantillas de agentes'));
-      console.log(theme.muted('  Crea un agente pre-configurado en segundos\n'));
+      console.log(section('Agent templates'));
+      console.log(theme.muted('  Create a pre-configured agent in seconds\n'));
 
       const rows = TEMPLATES.map((t, i) => [
         String(i + 1),
@@ -689,16 +690,16 @@ export const templatesCommand = new Command('templates')
         t.industry,
         t.description,
       ]);
-      console.log(createTable(['#', 'Nombre', 'Industria', 'Descripcion'], rows));
+      console.log(createTable(['#', 'Name', 'Industry', 'Description'], rows));
 
       // Paso 1: Seleccionar plantilla
       const { selected } = await (inquirer as any).prompt([{
         type: 'list',
         name: 'selected',
-        message: 'Selecciona una plantilla:',
+        message: 'Select a template:',
         choices: [
           ...TEMPLATES.map((t, i) => ({ name: `${t.name} (${t.industry})`, value: i })),
-          { name: 'Cancelar', value: -1 },
+          { name: 'Cancel', value: -1 },
         ],
       }]);
 
@@ -707,15 +708,15 @@ export const templatesCommand = new Command('templates')
       const template = TEMPLATES[selected];
 
       console.log(section(`${template.name}`));
-      console.log(kvPair('Industria', template.industry));
+      console.log(kvPair('Industry', template.industry));
       console.log(kvPair('Persona', `${template.config.person.name} - ${template.config.person.role}`));
-      console.log(kvPair('Acciones', String(template.config.actions.length)));
-      console.log(kvPair('Tool Calling', 'Activado'));
+      console.log(kvPair('Actions', String(template.config.actions.length)));
+      console.log(kvPair('Tool Calling', 'Enabled'));
       console.log();
 
       // Paso 2: Personalizar placeholders
-      console.log(theme.bold('\n  Personalizacion rapida'));
-      console.log(theme.muted('  Completa los datos de tu negocio:\n'));
+      console.log(theme.bold('\n  Quick customization'));
+      console.log(theme.muted('  Fill in your business details:\n'));
 
       const placeholderAnswers: Record<string, string> = {};
       for (const ph of template.placeholders) {
@@ -723,17 +724,17 @@ export const templatesCommand = new Command('templates')
           type: 'input',
           name: 'value',
           message: `${ph.label}:`,
-          validate: (v: string) => v.trim().length > 0 || 'Este campo es requerido',
+          validate: (v: string) => v.trim().length > 0 || 'This field is required',
         }]);
         placeholderAnswers[ph.key] = value.trim();
       }
 
       // Paso 3: Canales (WhatsApp, Messenger, Instagram, Telegram)
-      console.log(theme.bold('\n  Conexion de canales'));
+      console.log(theme.bold('\n  Channel connection'));
       const { wantChannels } = await (inquirer as any).prompt([{
         type: 'confirm',
         name: 'wantChannels',
-        message: 'Deseas conectar canales (WhatsApp, Messenger, Instagram, Telegram)?',
+        message: 'Connect channels (WhatsApp, Messenger, Instagram, Telegram)?',
         default: true,
       }]);
 
@@ -750,11 +751,11 @@ export const templatesCommand = new Command('templates')
       }
 
       // Paso 4: API Key de OpenAI
-      console.log(theme.bold('\n  Configuracion de IA'));
+      console.log(theme.bold('\n  AI configuration'));
       const { configureApiKey } = await (inquirer as any).prompt([{
         type: 'confirm',
         name: 'configureApiKey',
-        message: 'Deseas configurar tu API Key de OpenAI? (necesario para que el agente funcione)',
+        message: 'Configure your OpenAI API Key now? (required for the agent to work)',
         default: true,
       }]);
 
@@ -763,9 +764,9 @@ export const templatesCommand = new Command('templates')
         const { key } = await (inquirer as any).prompt([{
           type: 'password',
           name: 'key',
-          message: 'API Key de OpenAI (sk-...):',
+          message: 'OpenAI API Key (sk-...):',
           mask: '*',
-          validate: (v: string) => v.trim().length > 0 || 'La API Key es requerida',
+          validate: (v: string) => v.trim().length > 0 || 'The API Key is required',
         }]);
         apiToken = key.trim();
       }
@@ -774,7 +775,7 @@ export const templatesCommand = new Command('templates')
       const { timezone } = await (inquirer as any).prompt([{
         type: 'input',
         name: 'timezone',
-        message: 'Zona horaria (ej: America/Lima, America/Bogota, America/Mexico_City):',
+        message: 'Timezone (e.g. America/Lima, America/Bogota, America/Mexico_City):',
         default: template.config.timezone,
       }]);
 
@@ -796,33 +797,33 @@ export const templatesCommand = new Command('templates')
 
       // Si es --json, solo mostrar y salir
       if (options.json) {
-        console.log(section('JSON de configuracion'));
+        console.log(section('Configuration JSON'));
         logger.json(finalConfig);
         return;
       }
 
       // Paso 6: Confirmacion
-      console.log(section('Resumen'));
-      console.log(kvPair('Plantilla', template.name));
+      console.log(section('Summary'));
+      console.log(kvPair('Template', template.name));
       for (const ph of template.placeholders) {
         console.log(kvPair(ph.label, placeholderAnswers[ph.key]));
       }
-      console.log(kvPair('Canales', connectedChannels.length > 0 ? connectedChannels.map(c => `${c.channel} (${c.key})`).join(', ') : 'No configurado'));
-      console.log(kvPair('API Key OpenAI', apiToken ? 'Configurada' : 'No configurada (el agente no funcionara sin ella)'));
-      console.log(kvPair('Zona horaria', timezone));
-      console.log(kvPair('Acciones', String(finalConfig.actions.length)));
-      console.log(kvPair('IA', `${finalConfig.aiProviders[0].provider} / ${finalConfig.aiProviders[0].model}`));
+      console.log(kvPair('Channels', connectedChannels.length > 0 ? connectedChannels.map(c => `${c.channel} (${c.key})`).join(', ') : 'Not configured'));
+      console.log(kvPair('OpenAI API Key', apiToken ? 'Configured' : 'Not configured (the agent will not work without it)'));
+      console.log(kvPair('Timezone', timezone));
+      console.log(kvPair('Actions', String(finalConfig.actions.length)));
+      console.log(kvPair('AI', `${finalConfig.aiProviders[0].provider} / ${finalConfig.aiProviders[0].model}`));
       console.log();
 
       const { confirm } = await (inquirer as any).prompt([{
         type: 'confirm',
         name: 'confirm',
-        message: 'Crear el agente con esta configuracion?',
+        message: 'Create the agent with this configuration?',
         default: true,
       }]);
 
       if (!confirm) {
-        logger.warning('Creacion cancelada');
+        logger.warning('Creation cancelled');
         return;
       }
 
@@ -836,49 +837,56 @@ export const templatesCommand = new Command('templates')
 
       finalConfig.zone = credentials.zone;
 
-      const spinner = createSpinner('Creando agente...');
+      const spinner = createSpinner('Creating agent...');
       spinner.start();
 
       const result = await agent.addAgent(finalConfig);
 
-      spinner.succeed('Agente creado exitosamente');
+      spinner.succeed('Agent created successfully');
 
-      logger.title('Detalles del agente');
+      logger.title('Agent details');
       if (result.agentId) {
         logger.label('ID', result.agentId);
       }
-      logger.label('Nombre', finalConfig.name);
-      logger.label('Industria', template.industry);
+      logger.label('Name', finalConfig.name);
+      logger.label('Industry', template.industry);
       if (connectedChannels.length > 0) {
-        logger.label('Canales', connectedChannels.map(c => `${c.channel} (${c.key})`).join(', '));
+        logger.label('Channels', connectedChannels.map(c => `${c.channel} (${c.key})`).join(', '));
       }
-      logger.label('Acciones', String(finalConfig.actions.length));
+      logger.label('Actions', String(finalConfig.actions.length));
 
       console.log();
-      console.log(section('Siguientes pasos'));
+      console.log(section('Next steps'));
       if (connectedChannels.length === 0) {
-        console.log(theme.bold('  1.') + ' Conecta canales desde: ' + theme.success('plazbot agent chat -a <agentId>'));
-        console.log(theme.bold('  2.') + ' O conecta desde la plataforma en Ajustes > Integraciones');
+        console.log(theme.bold('  1.') + ' Connect channels from: ' + theme.success('plazbot agent chat -a <agentId>'));
+        console.log(theme.bold('  2.') + ' Or connect from the platform in Settings > Integrations');
       } else {
-        console.log(theme.bold('  1.') + ' Tu agente ya tiene canales conectados y activados');
+        console.log(theme.bold('  1.') + ' Your agent already has channels connected and enabled');
       }
-      console.log(theme.bold(`  ${connectedChannels.length === 0 ? '3' : '2'}.`) + ' Agrega tu API Key de OpenAI si no la configuraste');
+      console.log(theme.bold(`  ${connectedChannels.length === 0 ? '3' : '2'}.`) + ' Add your OpenAI API Key if you have not yet');
       console.log();
 
       if (!apiToken) {
-        logger.warning('Recuerda configurar tu API Key de OpenAI para que el agente funcione:');
+        logger.warning('Remember to configure your OpenAI API Key for the agent to work:');
         logger.dim(`plazbot agent ai-config ${result.agentId || '<agentId>'}`);
         console.log();
       }
-      logger.dim('Probar agente: plazbot agent chat -a ' + (result.agentId || '<agentId>'));
+      logger.dim('Test agent: plazbot agent chat -a ' + (result.agentId || '<agentId>'));
 
       if (options.dev) {
-        logger.warning('Ambiente: desarrollo');
+        logger.warning('Environment: development');
       }
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido';
+      const message = error instanceof Error ? error.message : 'Unknown error';
       logger.error(message);
       process.exit(1);
     }
   });
+
+addExamples(templatesCommand, [
+  { description: 'Pick a template and create the agent interactively',
+    command: 'plazbot agent templates' },
+  { description: 'Preview the resulting JSON without creating the agent',
+    command: 'plazbot agent templates --json' },
+]);

package/src/commands/agent/tools.ts

@@ -1,15 +1,16 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
 import inquirer from 'inquirer';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { createSpinner, createTable, theme, section, kvPair, statusBadge } from '../../utils/ui';
-import { AgentCommandOptions } from '../../types/agent';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { createSpinner, createTable, theme, section, kvPair, statusBadge } from '../../utils/ui.js';
+import { AgentCommandOptions } from '../../types/agent.js';
 
 export const toolsCommand = new Command('tools')
-  .description('Gestionar herramientas de Tool Calling del agente')
-  .argument('<agentId>', 'ID del agente')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Manage agent Tool Calling tools')
+  .argument('<agentId>', 'Agent ID')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, options: AgentCommandOptions) => {
     try {
       const credentials = await getStoredCredentials();
@@ -20,42 +21,42 @@ export const toolsCommand = new Command('tools')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      const spinner = createSpinner('Cargando agente...');
+      const spinner = createSpinner('Loading agent...');
       spinner.start();
       const _res: any = await agent.getAgentById({ id: agentId });
       const agentData = _res.agent || _res.data || _res;
       spinner.stop();
 
       console.log(section('Tool Calling - ' + (agentData.name || agentId)));
-      console.log(kvPair('Estado', agentData.useToolCalling ? theme.success('Activado') : theme.error('Desactivado')));
+      console.log(kvPair('Status', agentData.useToolCalling ? theme.success('Enabled') : theme.error('Disabled')));
 
       // Servicios
       const services = agentData.services || [];
       if (services.length > 0) {
-        console.log(section('Servicios (API calls)'));
+        console.log(section('Services (API calls)'));
         const rows = services.map((s: any) => [
           s.intent,
           s.method || 'POST',
           s.endpoint ? s.endpoint.substring(0, 40) + '...' : 'N/A',
           statusBadge(s.enabled !== false),
         ]);
-        console.log(createTable(['Intent', 'Method', 'Endpoint', 'Estado'], rows));
+        console.log(createTable(['Intent', 'Method', 'Endpoint', 'Status'], rows));
       } else {
-        console.log(theme.muted('\n  No hay servicios configurados'));
+        console.log(theme.muted('\n  No services configured'));
       }
 
       // Acciones
       const actions = agentData.actions || [];
       if (actions.length > 0) {
-        console.log(section('Acciones'));
+        console.log(section('Actions'));
         const rows = actions.map((a: any) => [
           a.intent,
           (a.action || []).map((ac: any) => ac.type).join(', '),
           statusBadge(a.enabled !== false),
         ]);
-        console.log(createTable(['Intent', 'Tipo', 'Estado'], rows));
+        console.log(createTable(['Intent', 'Type', 'Status'], rows));
       } else {
-        console.log(theme.muted('\n  No hay acciones configuradas'));
+        console.log(theme.muted('\n  No actions configured'));
       }
 
       // Menu de opciones
@@ -63,33 +64,33 @@ export const toolsCommand = new Command('tools')
       const { action } = await (inquirer as any).prompt([{
         type: 'list',
         name: 'action',
-        message: 'Que deseas hacer?',
+        message: 'What would you like to do?',
         choices: [
-          { name: 'Agregar servicio (API call)', value: 'add-service' },
-          { name: 'Agregar accion', value: 'add-action' },
-          { name: agentData.useToolCalling ? 'Desactivar Tool Calling' : 'Activar Tool Calling', value: 'toggle' },
-          { name: 'Salir', value: 'exit' },
+          { name: 'Add service (API call)', value: 'add-service' },
+          { name: 'Add action', value: 'add-action' },
+          { name: agentData.useToolCalling ? 'Disable Tool Calling' : 'Enable Tool Calling', value: 'toggle' },
+          { name: 'Exit', value: 'exit' },
         ],
       }]);
 
       if (action === 'exit') return;
 
       if (action === 'toggle') {
-        const toggleSpinner = createSpinner('Actualizando...');
+        const toggleSpinner = createSpinner('Updating...');
         toggleSpinner.start();
         const { id: _i1, _id: _o1, ...updatedConfig } = { ...agentData, useToolCalling: !agentData.useToolCalling };
         await agent.updateAgent(agentId, updatedConfig);
-        toggleSpinner.succeed(`Tool Calling ${!agentData.useToolCalling ? 'activado' : 'desactivado'}`);
+        toggleSpinner.succeed(`Tool Calling ${!agentData.useToolCalling ? 'enabled' : 'disabled'}`);
         return;
       }
 
       if (action === 'add-service') {
         const svc = await (inquirer as any).prompt([
-          { type: 'input', name: 'intent', message: 'Nombre/intent del servicio:', validate: (v: string) => v.length > 0 || 'Requerido' },
-          { type: 'input', name: 'reference', message: 'Palabras clave:', default: '' },
-          { type: 'list', name: 'method', message: 'Metodo HTTP:', choices: ['GET', 'POST'] },
-          { type: 'input', name: 'endpoint', message: 'URL del endpoint:', validate: (v: string) => v.length > 0 || 'Requerido' },
-          { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+          { type: 'input', name: 'intent', message: 'Service name/intent:', validate: (v: string) => v.length > 0 || 'Required' },
+          { type: 'input', name: 'reference', message: 'Keywords:', default: '' },
+          { type: 'list', name: 'method', message: 'HTTP method:', choices: ['GET', 'POST'] },
+          { type: 'input', name: 'endpoint', message: 'Endpoint URL:', validate: (v: string) => v.length > 0 || 'Required' },
+          { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
         ]);
 
         const newService = {
@@ -108,33 +109,33 @@ export const toolsCommand = new Command('tools')
 
         const updatedServices = [...services, newService];
         const { id: _i2, _id: _o2, ...updatedConfig } = { ...agentData, services: updatedServices, useToolCalling: true };
-        const updateSpinner = createSpinner('Guardando servicio...');
+        const updateSpinner = createSpinner('Saving service...');
         updateSpinner.start();
         await agent.updateAgent(agentId, updatedConfig);
-        updateSpinner.succeed(`Servicio "${svc.intent}" agregado`);
+        updateSpinner.succeed(`Service "${svc.intent}" added`);
       }
 
       if (action === 'add-action') {
         const act = await (inquirer as any).prompt([
-          { type: 'input', name: 'intent', message: 'Nombre/intent de la accion:', validate: (v: string) => v.length > 0 || 'Requerido' },
-          { type: 'input', name: 'reference', message: 'Palabras clave:', default: '' },
+          { type: 'input', name: 'intent', message: 'Action name/intent:', validate: (v: string) => v.length > 0 || 'Required' },
+          { type: 'input', name: 'reference', message: 'Keywords:', default: '' },
           {
-            type: 'list', name: 'actionType', message: 'Tipo de accion:',
+            type: 'list', name: 'actionType', message: 'Action type:',
             choices: [
-              { name: 'Agendar evento', value: 'action.event.add' },
-              { name: 'Actualizar evento (reagendar)', value: 'action.event.update' },
-              { name: 'Listar eventos', value: 'action.event.list' },
-              { name: 'Eliminar evento (cancelar)', value: 'action.event.delete' },
-              { name: 'Agregar tag', value: 'action.tag' },
-              { name: 'Cambiar stage', value: 'action.stage' },
-              { name: 'Derivar a agente humano', value: 'action.agentShutDown' },
-              { name: 'Marcar como resuelto', value: 'action.solved' },
-              { name: 'Asignar agente', value: 'action.asign' },
-              { name: 'Segmentacion', value: 'action.segmentation' },
+              { name: 'Schedule event', value: 'action.event.add' },
+              { name: 'Update event (reschedule)', value: 'action.event.update' },
+              { name: 'List events', value: 'action.event.list' },
+              { name: 'Delete event (cancel)', value: 'action.event.delete' },
+              { name: 'Add tag', value: 'action.tag' },
+              { name: 'Change stage', value: 'action.stage' },
+              { name: 'Hand off to human agent', value: 'action.agentShutDown' },
+              { name: 'Mark as resolved', value: 'action.solved' },
+              { name: 'Assign agent', value: 'action.asign' },
+              { name: 'Segmentation', value: 'action.segmentation' },
             ],
           },
-          { type: 'input', name: 'actionValue', message: 'Valor (opcional):', default: '' },
-          { type: 'input', name: 'responseMessage', message: 'Mensaje de respuesta:', default: '' },
+          { type: 'input', name: 'actionValue', message: 'Value (optional):', default: '' },
+          { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
         ]);
 
         const newAction = {
@@ -148,15 +149,20 @@ export const toolsCommand = new Command('tools')
 
         const updatedActions = [...actions, newAction];
         const { id: _i3, _id: _o3, ...updatedConfig } = { ...agentData, actions: updatedActions, useToolCalling: true };
-        const updateSpinner = createSpinner('Guardando accion...');
+        const updateSpinner = createSpinner('Saving action...');
         updateSpinner.start();
         await agent.updateAgent(agentId, updatedConfig);
-        updateSpinner.succeed(`Accion "${act.intent}" agregada`);
+        updateSpinner.succeed(`Action "${act.intent}" added`);
       }
 
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido';
+      const message = error instanceof Error ? error.message : 'Unknown error';
       logger.error(message);
       process.exit(1);
     }
   });
+
+addExamples(toolsCommand, [
+  { description: 'View services/actions and add new ones interactively',
+    command: 'plazbot agent tools agt_AbcDef123' },
+]);

package/src/commands/agent/update.ts

@@ -1,28 +1,29 @@
 import { Command } from 'commander';
 import { Agent } from 'plazbot';
-import { getStoredCredentials } from '../../utils/credentials';
-import { logger } from '../../utils/logger';
-import { AgentCommandOptions } from '../../types/agent';
+import { getStoredCredentials } from '../../utils/credentials.js';
+import { logger } from '../../utils/logger.js';
+import { addExamples } from '../../utils/help.js';
+import { AgentCommandOptions } from '../../types/agent.js';
 import fs from 'fs/promises';
 
 export const updateCommand = new Command('update')
-  .description('Actualiza un agente existente en Plazbot')
-  .argument('<agentId>', 'ID del agente a actualizar')
-  .argument('<configPath>', 'Ruta al archivo de configuración JSON del agente')
-  .option('--dev', 'Usar ambiente de desarrollo', false)
+  .description('Update an existing agent in Plazbot')
+  .argument('<agentId>', 'Agent ID to update')
+  .argument('<configPath>', 'Path to the agent JSON configuration file')
+  .option('--dev', 'Use development environment', false)
   .action(async (agentId: string, configPath: string, options: AgentCommandOptions) => {
     try {
       // Obtener credenciales guardadas
       const credentials = await getStoredCredentials();
-      
+
       // Leer archivo de configuración del agente
       let agentConfig;
       try {
         const fileContent = await fs.readFile(configPath, 'utf-8');
         agentConfig = JSON.parse(fileContent);
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Error desconocido';
-        throw new Error(`Error al leer el archivo de configuración: ${errorMessage}`);
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Error reading configuration file: ${errorMessage}`);
       }
 
       // Crear instancia del agente con las credenciales guardadas
@@ -33,21 +34,28 @@ export const updateCommand = new Command('update')
         ...(options.dev && { customUrl: "http://localhost:5090" })
       });
 
-      logger.dim('Actualizando agente...');
-      
+      logger.dim('Updating agent...');
+
       // Actualizar el agente
       const result = await agent.updateAgent(agentId, agentConfig);
-      
-      logger.success('Agente actualizado exitosamente');
-      logger.info(`Mensaje: ${result.message}`);
-      
+
+      logger.success('Agent updated successfully');
+      logger.info(`Message: ${result.message}`);
+
       if (options.dev) {
-        logger.warning('Ambiente: desarrollo');
+        logger.warning('Environment: development');
       }
-      
+
     } catch (error) {
-      const message = error instanceof Error ? error.message : 'Error desconocido al actualizar el agente';
+      const message = error instanceof Error ? error.message : 'Unknown error while updating the agent';
       logger.error(message);
       process.exit(1);
     }
-  }); 
+  });
+
+addExamples(updateCommand, [
+  { description: 'Push a new configuration to the agent',
+    command: 'plazbot agent update agt_AbcDef123 ./agent.json' },
+  { description: 'Tip: export → edit → update workflow',
+    command: 'plazbot agent export agt_AbcDef123 -o agent.json && plazbot agent update agt_AbcDef123 ./agent.json' },
+]);