plazbot-cli 0.4.1 → 0.5.1

package/dist/commands/agent/wizard.js

@@ -3,12 +3,56 @@ import chalk from 'chalk';
 import axios from 'axios';
 import ora from 'ora';
 import { theme, section, kvPair } from '../../utils/ui.js';
-const MODELS = {
-    openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-4', 'gpt-3.5-turbo', 'o1-preview', 'o1-mini'],
-    claude: ['claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
-    gemini: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
-};
+import { requireInteractive } from '../../utils/confirm.js';
+import { normalizePhone } from '../../utils/phone.js';
+import { CliError } from '../../utils/output.js';
+import { AI_MODELS, AI_PROVIDERS, DEFAULT_AI_MODEL, DEFAULT_TEMPERATURE, DEFAULT_MAX_TOKENS } from './ai-config.js';
+import { promptService, promptAction } from './tools.js';
 const COLORS = ['blue', 'green', 'orange', 'gray', 'white'];
+// Labels are English; values stay as the platform stores them (the front uses the same values).
+const TONES = [
+    { name: 'Professional', value: 'profesional' },
+    { name: 'Friendly', value: 'amigable' },
+    { name: 'Formal', value: 'formal' },
+    { name: 'Casual', value: 'casual' },
+    { name: 'Technical', value: 'tecnico' },
+    { name: 'Empathetic', value: 'empatico' },
+];
+const STYLES = [
+    { name: 'Concise', value: 'conciso' },
+    { name: 'Detailed', value: 'detallado' },
+    { name: 'Conversational', value: 'conversacional' },
+    { name: 'Direct', value: 'directo' },
+];
+const LANGUAGES = [
+    { name: 'Spanish', value: 'Espanol' },
+    { name: 'English', value: 'English' },
+    { name: 'Portuguese', value: 'Portugues' },
+    { name: 'French', value: 'Frances' },
+];
+// Default fallback messages are shown to end users, so they follow the agent language.
+const FALLBACK_DEFAULTS = {
+    Espanol: {
+        noAnswer: 'Lo siento, no tengo información sobre eso. ¿Puedo ayudarte con otra consulta?',
+        serviceError: 'Disculpa, estamos experimentando dificultades técnicas. Intenta de nuevo en unos momentos.',
+        doNotUnderstand: 'No estoy seguro de entender tu consulta. ¿Podrías reformularla?',
+    },
+    English: {
+        noAnswer: "Sorry, I don't have information about that. Can I help you with something else?",
+        serviceError: "Sorry, we're having technical difficulties. Please try again in a few moments.",
+        doNotUnderstand: "I'm not sure I understand your question. Could you rephrase it?",
+    },
+    Portugues: {
+        noAnswer: 'Desculpe, não tenho informações sobre isso. Posso ajudar com outra dúvida?',
+        serviceError: 'Desculpe, estamos com dificuldades técnicas. Tente novamente em alguns instantes.',
+        doNotUnderstand: 'Não tenho certeza se entendi sua pergunta. Poderia reformulá-la?',
+    },
+    Frances: {
+        noAnswer: "Désolé, je n'ai pas d'informations à ce sujet. Puis-je vous aider avec autre chose ?",
+        serviceError: 'Désolé, nous rencontrons des difficultés techniques. Réessayez dans quelques instants.',
+        doNotUnderstand: "Je ne suis pas sûr de comprendre votre question. Pourriez-vous la reformuler ?",
+    },
+};
 function getBaseUrl(zone, dev) {
     if (dev)
         return 'http://localhost:5090';
@@ -40,14 +84,9 @@ function getIntegrationKey(ig) {
     return ig.aliasName || ig.srcName || ig.id;
 }
 async function fetchWorkspaceIntegrations(baseUrl, workspaceId, headers) {
-    try {
-        const wkRes = await axios.get(`${baseUrl}/api/workspace/${workspaceId}`, { headers });
-        const wsData = Array.isArray(wkRes.data) ? wkRes.data[0] : wkRes.data;
-        return wsData?.integrations || [];
-    }
-    catch {
-        return [];
-    }
+    const wkRes = await axios.get(`${baseUrl}/api/workspace/${workspaceId}`, { headers });
+    const wsData = Array.isArray(wkRes.data) ? wkRes.data[0] : wkRes.data;
+    return wsData?.integrations || [];
 }
 async function activateIntegration(baseUrl, workspaceId, integrationId, headers) {
     try {
@@ -58,7 +97,61 @@ async function activateIntegration(baseUrl, workspaceId, integrationId, headers)
         return false;
     }
 }
+async function activateWithSpinner(baseUrl, workspaceId, integrationId, headers) {
+    const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
+    const activated = await activateIntegration(baseUrl, workspaceId, integrationId, headers);
+    if (activated) {
+        actSpinner.succeed(chalk.hex('#4ade80')('Integration activated.'));
+    }
+    else {
+        actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. Activate it from the platform (Settings > Integrations).'));
+    }
+}
+/**
+ * Resolves after `ms`, or earlier when the user presses Enter. Restores the terminal
+ * mode afterwards and keeps Ctrl+C working while stdin is in raw mode.
+ */
+function waitOrEnter(ms) {
+    let cleanup = () => { };
+    const promise = new Promise(resolve => {
+        const stdin = process.stdin;
+        const isTTY = !!stdin.isTTY;
+        const wasRaw = isTTY ? stdin.isRaw : false;
+        const timer = setTimeout(() => finish('timeout'), ms);
+        const onData = (data) => {
+            const s = data.toString();
+            if (s.includes('\u0003')) {
+                cleanup();
+                process.exit(130);
+            }
+            if (s.includes('\n') || s.includes('\r'))
+                finish('enter');
+        };
+        function finish(reason) {
+            cleanup();
+            resolve(reason);
+        }
+        cleanup = () => {
+            clearTimeout(timer);
+            stdin.removeListener('data', onData);
+            if (isTTY) {
+                try {
+                    stdin.setRawMode(!!wasRaw);
+                }
+                catch { /* terminal already closed */ }
+            }
+            stdin.pause();
+            cleanup = () => { };
+        };
+        if (isTTY)
+            stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on('data', onData);
+    });
+    return { promise, cancel: () => cleanup() };
+}
 export async function connectChannelFlow(ctx) {
+    requireInteractive('Connecting a channel', 'Connect channels later from the platform (Settings > Integrations).');
     const channels = [];
     const baseUrl = getBaseUrl(ctx.zone, ctx.dev);
     const headers = {
@@ -76,20 +169,25 @@ export async function connectChannelFlow(ctx) {
             }]);
         const channelLabel = CHANNEL_CHOICES.find(c => c.value === channelType)?.name || channelType;
         const targetType = channelType === 'whatsapp_business' ? 'whatsapp' : channelType;
-        // Cargar integraciones existentes del tipo seleccionado
+        // Load the workspace integrations of the selected type
         const loadSpinner = ora({ text: chalk.gray('Loading integrations...'), spinner: 'dots', color: 'green' }).start();
-        const allIntegrations = await fetchWorkspaceIntegrations(baseUrl, ctx.workspaceId, headers);
+        let allIntegrations = [];
+        try {
+            allIntegrations = await fetchWorkspaceIntegrations(baseUrl, ctx.workspaceId, headers);
+            loadSpinner.stop();
+        }
+        catch (err) {
+            loadSpinner.warn(chalk.hex('#FFA726')(`Could not load existing integrations (${err instanceof Error ? err.message : err}). You can still generate a connection link.`));
+        }
         const existing = allIntegrations.filter((ig) => ig.type === targetType);
-        loadSpinner.stop();
         let selectedIntegration = null;
         if (existing.length > 0) {
-            // Mostrar integraciones existentes + opcion de agregar nueva
             const choices = existing.map((ig) => ({
-                name: `${getIntegrationLabel(ig)}`,
+                name: `${getIntegrationLabel(ig)}${ig.isActive ? '' : chalk.gray(' (inactive)')}`,
                 value: ig.id,
             }));
             choices.push(new inquirer.Separator());
-            choices.push({ name: chalk.hex('#4ade80')('+ Add a new one (generate link)'), value: '__new__' });
+            choices.push({ name: chalk.hex('#4ade80')('+ Connect a new one (generate link)'), value: '__new__' });
             const { selected } = await inquirer.prompt([{
                     type: 'list',
                     name: 'selected',
@@ -97,19 +195,10 @@ export async function connectChannelFlow(ctx) {
                     choices,
                 }]);
             if (selected !== '__new__') {
-                // Selecciono una existente
                 selectedIntegration = existing.find((ig) => ig.id === selected);
                 const label = getIntegrationLabel(selectedIntegration);
-                // Activar la integracion si no esta activa
                 if (!selectedIntegration.isActive) {
-                    const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
-                    const activated = await activateIntegration(baseUrl, ctx.workspaceId, selectedIntegration.id, headers);
-                    if (activated) {
-                        actSpinner.succeed(chalk.hex('#4ade80')('Integration activated successfully.'));
-                    }
-                    else {
-                        actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. You can activate it manually from the platform.'));
-                    }
+                    await activateWithSpinner(baseUrl, ctx.workspaceId, selectedIntegration.id, headers);
                 }
                 channels.push({
                     channel: CHANNEL_AGENT_MAP[channelType],
@@ -119,130 +208,87 @@ export async function connectChannelFlow(ctx) {
                 console.log(chalk.hex('#4ade80')(`  Channel linked: ${label}`));
             }
         }
-        // Si no hay existentes o eligio "Agregar nuevo" → generar link de onboarding
+        // No existing integrations, or "connect a new one": generate an onboarding link
         if (!selectedIntegration) {
             const spinner = ora({ text: chalk.gray('Generating connection link...'), spinner: 'dots', color: 'green' }).start();
             try {
                 const linkRes = await axios.post(`${baseUrl}/api/workspace/${ctx.workspaceId}/onboarding-link`, { type: channelType }, { headers });
                 if (!linkRes.data?.success) {
-                    spinner.fail(chalk.hex('#EF5350')(`Error: ${linkRes.data?.message || 'Could not generate the link'}`));
+                    spinner.fail(chalk.hex('#EF5350')(`Could not generate the link: ${linkRes.data?.message || 'unknown error'}.`));
                 }
                 else {
                     const shortUrl = linkRes.data.data?.shortUrl || '';
                     spinner.stop();
-                    // Mostrar link
                     console.log();
-                    console.log(chalk.hex('#4CAF50')('  ─'.repeat(32)));
-                    console.log(chalk.bold(`  Send this link to connect ${channelLabel}:`));
+                    console.log(chalk.hex('#4CAF50')('  ' + '─'.repeat(60)));
+                    console.log(chalk.bold(`  Open this link (or send it to the account owner) to connect ${channelLabel}:`));
                     console.log();
                     console.log('  ' + chalk.hex('#22d3ee')(shortUrl));
                     console.log();
-                    console.log(chalk.hex('#4CAF50')('  ─'.repeat(32)));
+                    console.log(chalk.hex('#4CAF50')('  ' + '─'.repeat(60)));
                     console.log();
-                    // Guardar IDs actuales para detectar nuevos
+                    // Remember current IDs to detect the new integration
                     const prevIds = new Set(allIntegrations.map((i) => i.id));
-                    // Polling para detectar nueva integracion (Enter para saltar)
-                    const pollSpinner = ora({ text: chalk.gray('Waiting for connection... (Enter to skip)'), spinner: 'dots', color: 'cyan' }).start();
                     const POLL_INTERVAL = 5000;
                     const MAX_POLLS = 60;
-                    let detected = null;
+                    const pollSpinner = ora({ text: chalk.gray('Waiting for the connection... (press Enter to skip)'), spinner: 'dots', color: 'cyan' }).start();
+                    const skip = waitOrEnter(POLL_INTERVAL * MAX_POLLS + 1000);
                     let skipped = false;
-                    // Escuchar Enter para saltar
-                    const skipPromise = new Promise(resolve => {
-                        const onData = (data) => {
-                            if (data.toString().includes('\n') || data.toString().includes('\r')) {
-                                skipped = true;
-                                process.stdin.removeListener('data', onData);
-                                if (wasRaw)
-                                    process.stdin.setRawMode(false);
-                                resolve();
-                            }
-                        };
-                        const wasRaw = process.stdin.isRaw;
-                        if (process.stdin.isTTY)
-                            process.stdin.setRawMode(true);
-                        process.stdin.resume();
-                        process.stdin.on('data', onData);
-                        setTimeout(() => {
-                            process.stdin.removeListener('data', onData);
-                            if (process.stdin.isTTY && wasRaw !== undefined) {
-                                try {
-                                    process.stdin.setRawMode(wasRaw);
-                                }
-                                catch { }
-                            }
-                            resolve();
-                        }, POLL_INTERVAL * MAX_POLLS + 1000);
-                    });
+                    skip.promise.then(reason => { if (reason === 'enter')
+                        skipped = true; });
+                    let detected = null;
+                    let pollErrors = 0;
                     for (let i = 0; i < MAX_POLLS; i++) {
-                        await Promise.race([
-                            new Promise(r => setTimeout(r, POLL_INTERVAL)),
-                            skipPromise,
-                        ]);
+                        await Promise.race([new Promise(r => setTimeout(r, POLL_INTERVAL)), skip.promise]);
                         if (skipped)
                             break;
                         try {
                             const freshIntegrations = await fetchWorkspaceIntegrations(baseUrl, ctx.workspaceId, headers);
                             const newOnes = freshIntegrations.filter((ig) => !prevIds.has(ig.id));
                             if (newOnes.length > 0) {
-                                const match = newOnes.find((ig) => ig.type === targetType);
-                                detected = match || newOnes[0];
+                                detected = newOnes.find((ig) => ig.type === targetType) || newOnes[0];
                                 break;
                             }
                         }
-                        catch { }
+                        catch {
+                            pollErrors++;
+                        }
                         const elapsed = Math.floor(((i + 1) * POLL_INTERVAL) / 1000);
-                        pollSpinner.text = chalk.gray(`Waiting for connection... ${elapsed}s (Enter to skip)`);
+                        pollSpinner.text = chalk.gray(`Waiting for the connection... ${elapsed}s (press Enter to skip)${pollErrors ? ` · ${pollErrors} failed checks` : ''}`);
                     }
+                    skip.cancel();
                     if (detected) {
-                        const detectedName = getIntegrationLabel(detected);
-                        pollSpinner.succeed(chalk.hex('#4ade80')(`Connection detected: ${detectedName}`));
-                        // Activar la integracion detectada
-                        const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
-                        const activated = await activateIntegration(baseUrl, ctx.workspaceId, detected.id, headers);
-                        if (activated) {
-                            actSpinner.succeed(chalk.hex('#4ade80')('Integration activated successfully.'));
-                        }
-                        else {
-                            actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. You can activate it manually from the platform.'));
-                        }
+                        pollSpinner.succeed(chalk.hex('#4ade80')(`Connection detected: ${getIntegrationLabel(detected)}`));
+                        await activateWithSpinner(baseUrl, ctx.workspaceId, detected.id, headers);
                         channels.push({
                             channel: CHANNEL_AGENT_MAP[channelType],
                             key: getIntegrationKey(detected),
                             multianswer: false,
                         });
-                        console.log(chalk.hex('#4ade80')('  Channel linked successfully.'));
+                        console.log(chalk.hex('#4ade80')('  Channel linked.'));
                     }
                     else {
-                        pollSpinner.warn(chalk.hex('#FFA726')(skipped ? 'Skipped.' : 'Timeout: no connection detected.'));
+                        pollSpinner.warn(chalk.hex('#FFA726')(skipped ? 'Skipped.' : 'Timed out: no new connection detected.'));
                         const { action } = await inquirer.prompt([{
                                 type: 'list', name: 'action',
                                 message: 'What would you like to do?',
                                 choices: [
-                                    { name: 'Enter ID manually', value: 'manual' },
-                                    { name: 'Skip', value: 'skip' },
+                                    { name: 'Enter the integration ID manually', value: 'manual' },
+                                    { name: 'Skip this channel', value: 'skip' },
                                 ],
                             }]);
                         if (action === 'manual') {
                             const { key } = await inquirer.prompt([
-                                { type: 'input', name: 'key', message: `${channelLabel} channel ID/number:`, validate: (v) => v.length > 0 || 'Required' },
+                                { type: 'input', name: 'key', message: `${channelLabel} integration ID:`, validate: (v) => v.trim().length > 0 || 'Required' },
                             ]);
-                            // Activar la integracion ingresada manualmente
-                            const actSpinner = ora({ text: chalk.gray('Activating integration...'), spinner: 'dots', color: 'green' }).start();
-                            const activated = await activateIntegration(baseUrl, ctx.workspaceId, key, headers);
-                            if (activated) {
-                                actSpinner.succeed(chalk.hex('#4ade80')('Integration activated successfully.'));
-                            }
-                            else {
-                                actSpinner.warn(chalk.hex('#FFA726')('Could not activate the integration. You can activate it manually from the platform.'));
-                            }
-                            channels.push({ channel: CHANNEL_AGENT_MAP[channelType], key, multianswer: false });
+                            await activateWithSpinner(baseUrl, ctx.workspaceId, key.trim(), headers);
+                            channels.push({ channel: CHANNEL_AGENT_MAP[channelType], key: key.trim(), multianswer: false });
                         }
                     }
                 }
             }
             catch (err) {
-                spinner.fail(chalk.hex('#EF5350')(`Error: ${err instanceof Error ? err.message : err}`));
+                spinner.fail(chalk.hex('#EF5350')(`Could not generate the link: ${err instanceof Error ? err.message : err}.`));
             }
         }
         const { more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Connect another channel?', default: false }]);
@@ -250,22 +296,32 @@ export async function connectChannelFlow(ctx) {
     }
     return channels;
 }
+function validatePhone(v) {
+    try {
+        normalizePhone(v);
+        return true;
+    }
+    catch (e) {
+        return e instanceof CliError ? e.message : 'Invalid phone number';
+    }
+}
 export async function runAgentWizard(zone, workspaceId, apiKey, dev) {
-    console.log(section('Create new AI agent'));
-    console.log(theme.muted('  Answer the following questions to configure your agent.\n'));
-    // Paso 1: Informacion basica
+    requireInteractive('The agent wizard', 'Pass a JSON file instead: plazbot agent create ./agent.json');
+    console.log(section('Create a new AI agent'));
+    console.log(theme.muted('  Answer a few questions to configure your agent. Press Enter to accept defaults.\n'));
+    // Step 1: basic information
     console.log(theme.bold('\n  Step 1/8: Basic information'));
     const basic = await inquirer.prompt([
         {
             type: 'input',
             name: 'name',
             message: 'Agent name:',
-            validate: (v) => v.length > 0 || 'Name is required',
+            validate: (v) => v.trim().length > 0 || 'The name is required',
         },
         {
             type: 'input',
             name: 'description',
-            message: 'Short description:',
+            message: 'Short description (optional):',
             default: '',
         },
         {
@@ -275,11 +331,15 @@ export async function runAgentWizard(zone, workspaceId, apiKey, dev) {
             default: 'You are a friendly and professional virtual assistant.',
         },
         {
-            type: 'number',
+            type: 'input',
             name: 'buffer',
-            message: 'Conversation buffer (3-20 messages):',
-            default: 5,
-            validate: (v) => (v >= 3 && v <= 20) || 'Must be between 3 and 20',
+            message: 'Conversation memory: how many previous messages the agent reads (3-20):',
+            default: '5',
+            validate: (v) => {
+                const n = Number(String(v).trim());
+                return (Number.isInteger(n) && n >= 3 && n <= 20) || 'Enter a whole number of messages between 3 and 20';
+            },
+            filter: (v) => String(v).trim(),
         },
         {
             type: 'list',
@@ -289,283 +349,132 @@ export async function runAgentWizard(zone, workspaceId, apiKey, dev) {
             default: 'blue',
         },
     ]);
-    // Paso 2: Personalidad
+    // Step 2: personality
     console.log(theme.bold('\n  Step 2/8: Personality and instructions'));
     const personality = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'tone',
-            message: 'Communication tone:',
-            choices: ['profesional', 'amigable', 'formal', 'casual', 'tecnico', 'empatico'],
-            default: 'profesional',
-        },
-        {
-            type: 'list',
-            name: 'style',
-            message: 'Response style:',
-            choices: ['conciso', 'detallado', 'conversacional', 'directo'],
-            default: 'conciso',
-        },
-        {
-            type: 'input',
-            name: 'personality',
-            message: 'Personality in one sentence:',
-            default: 'Helpful and knowledgeable',
-        },
-        {
-            type: 'input',
-            name: 'objective',
-            message: 'Main objective of the agent:',
-            default: 'Help users with their queries',
-        },
-        {
-            type: 'list',
-            name: 'language',
-            message: 'Primary language:',
-            choices: ['Espanol', 'English', 'Portugues', 'Frances'],
-            default: 'Espanol',
-        },
-        {
-            type: 'confirm',
-            name: 'useEmojis',
-            message: 'Use emojis in responses?',
-            default: true,
-        },
+        { type: 'list', name: 'tone', message: 'Tone:', choices: TONES, default: 'profesional' },
+        { type: 'list', name: 'style', message: 'Response style:', choices: STYLES, default: 'conciso' },
+        { type: 'input', name: 'personality', message: 'Personality in one sentence:', default: 'Helpful and knowledgeable' },
+        { type: 'input', name: 'objective', message: 'Main objective of the agent:', default: 'Help users with their questions' },
+        { type: 'list', name: 'language', message: 'Language the agent replies in:', choices: LANGUAGES, default: 'Espanol' },
+        { type: 'confirm', name: 'useEmojis', message: 'Use emojis in replies?', default: true },
     ]);
-    // Paso 3: Persona
+    // Step 3: identity
     console.log(theme.bold('\n  Step 3/8: Agent identity'));
     const person = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'name',
-            message: 'Character name (how it introduces itself):',
-            default: basic.name,
-        },
-        {
-            type: 'input',
-            name: 'role',
-            message: 'Role (e.g. Sales assistant, Tech support):',
-            default: 'Virtual assistant',
-        },
-        {
-            type: 'confirm',
-            name: 'firstPerson',
-            message: 'Speak in first person?',
-            default: true,
-        },
+        { type: 'input', name: 'name', message: 'Character name (how it introduces itself):', default: basic.name.trim() },
+        { type: 'input', name: 'role', message: 'Role (e.g. Sales assistant, Tech support):', default: 'Virtual assistant' },
+        { type: 'confirm', name: 'firstPerson', message: 'Speak in first person?', default: true },
     ]);
-    // Paso 4: Fallbacks
+    // Step 4: fallbacks (end-user facing, defaults follow the agent language)
     console.log(theme.bold('\n  Step 4/8: Fallback messages'));
+    console.log(theme.muted('  Sent to your customers, in the agent language.\n'));
+    const fb = FALLBACK_DEFAULTS[personality.language] || FALLBACK_DEFAULTS.Espanol;
     const fallbacks = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'noAnswer',
-            message: 'When it has no answer:',
-            default: 'Lo siento, no tengo informacion sobre eso. Puedo ayudarte con otra consulta?',
-        },
-        {
-            type: 'input',
-            name: 'serviceError',
-            message: 'When there is a service error:',
-            default: 'Disculpa, estamos experimentando dificultades tecnicas. Intenta de nuevo en unos momentos.',
-        },
-        {
-            type: 'input',
-            name: 'misunderstanding',
-            message: 'When it does not understand the question:',
-            default: 'No estoy seguro de entender tu consulta. Podrias reformularla?',
-        },
+        { type: 'input', name: 'noAnswer', message: 'When it has no answer:', default: fb.noAnswer },
+        { type: 'input', name: 'serviceError', message: 'When an external service fails:', default: fb.serviceError },
+        { type: 'input', name: 'misunderstanding', message: 'When it does not understand the question:', default: fb.doNotUnderstand },
     ]);
-    // Paso 5: Tool Calling
+    // Step 5: Tool Calling
     console.log(theme.bold('\n  Step 5/8: Tool Calling'));
-    console.log(theme.muted('  Tool Calling lets the agent execute automatic actions\n'));
+    console.log(theme.muted('  Tool Calling lets the agent call your APIs and run actions (tag, stage, hand off...).\n'));
     const { useToolCalling } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'useToolCalling',
-            message: 'Enable Tool Calling?',
-            default: true,
-        },
+        { type: 'confirm', name: 'useToolCalling', message: 'Enable Tool Calling?', default: true },
     ]);
-    // Servicios (API calls)
     const services = [];
+    const actions = [];
     if (useToolCalling) {
         const { addServices } = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'addServices',
-                message: 'Add external services (API calls)?',
-                default: false,
+                type: 'confirm', name: 'addServices', message: 'Add services (external API calls)?', default: false,
             }]);
-        if (addServices) {
-            let addMore = true;
-            while (addMore) {
-                console.log(theme.muted('\n  New service:'));
-                const svc = await inquirer.prompt([
-                    { type: 'input', name: 'intent', message: 'Service name/intent:', validate: (v) => v.length > 0 || 'Required' },
-                    { type: 'input', name: 'reference', message: 'Reference keywords:', default: '' },
-                    { type: 'list', name: 'method', message: 'HTTP method:', choices: ['GET', 'POST'] },
-                    { type: 'input', name: 'endpoint', message: 'Endpoint URL:', validate: (v) => v.length > 0 || 'Required' },
-                    { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
-                ]);
-                // Required fields
-                const fields = [];
-                const { addFields } = await inquirer.prompt([{
-                        type: 'confirm', name: 'addFields',
-                        message: 'Add required fields?', default: false,
-                    }]);
-                if (addFields) {
-                    let moreFields = true;
-                    while (moreFields) {
-                        const field = await inquirer.prompt([
-                            { type: 'input', name: 'name', message: 'Field name:' },
-                            { type: 'list', name: 'type', message: 'Type:', choices: ['string', 'number', 'boolean', 'date'] },
-                            { type: 'input', name: 'description', message: 'Description:' },
-                            { type: 'input', name: 'promptHint', message: 'Hint for the LLM:' },
-                        ]);
-                        fields.push(field);
-                        const { more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another field?', default: false }]);
-                        moreFields = more;
-                    }
-                }
-                services.push({
-                    intent: svc.intent,
-                    reference: svc.reference,
-                    enabled: true,
-                    method: svc.method,
-                    endpoint: svc.endpoint,
-                    requiredFields: fields,
-                    headers: {},
-                    bodyTemplate: {},
-                    responseMapping: {},
-                    responseMessage: svc.responseMessage,
-                    responseConditions: [],
-                });
-                const { more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another service?', default: false }]);
-                addMore = more;
-            }
+        let more = addServices;
+        while (more) {
+            console.log(theme.muted('\n  New service:'));
+            services.push(await promptService());
+            ({ more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another service?', default: false }]));
         }
-    }
-    // Acciones
-    const actions = [];
-    if (useToolCalling) {
         const { addActions } = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'addActions',
-                message: 'Add actions (tag, stage, assign agent)?',
-                default: false,
+                type: 'confirm', name: 'addActions', message: 'Add actions (tag, stage, assign, hand off to a human...)?', default: false,
             }]);
-        if (addActions) {
-            let addMore = true;
-            while (addMore) {
-                console.log(theme.muted('\n  New action:'));
-                const act = await inquirer.prompt([
-                    { type: 'input', name: 'intent', message: 'Action name/intent:', validate: (v) => v.length > 0 || 'Required' },
-                    { type: 'input', name: 'reference', message: 'Reference keywords:', default: '' },
-                    {
-                        type: 'list', name: 'actionType', message: 'Action type:',
-                        choices: [
-                            { 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: 'Action value:', default: '' },
-                    { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
-                ]);
-                actions.push({
-                    intent: act.intent,
-                    reference: act.reference,
-                    enabled: true,
-                    requiredFields: [],
-                    responseMessage: act.responseMessage,
-                    action: [{ type: act.actionType, value: act.actionValue }],
-                });
-                const { more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another action?', default: false }]);
-                addMore = more;
-            }
+        more = addActions;
+        while (more) {
+            console.log(theme.muted('\n  New action:'));
+            actions.push(await promptAction());
+            ({ more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another action?', default: false }]));
         }
     }
-    // Paso 6: AI Provider
+    // Step 6: AI provider
     console.log(theme.bold('\n  Step 6/8: AI provider'));
     const { configureAI } = await inquirer.prompt([{
             type: 'confirm',
             name: 'configureAI',
-            message: 'Configure a custom AI provider?',
+            message: 'Use your own AI provider and API key? (No = platform default AI)',
             default: false,
         }]);
     const aiProviders = [];
     if (configureAI) {
-        const ai = await inquirer.prompt([
-            { type: 'list', name: 'provider', message: 'Provider:', choices: ['openai', 'claude', 'gemini'] },
+        const { provider } = await inquirer.prompt([
+            { type: 'list', name: 'provider', message: 'Provider:', choices: AI_PROVIDERS.map(p => ({ name: p.label, value: p.value })) },
         ]);
-        const models = MODELS[ai.provider] || MODELS.openai;
+        const providerId = provider;
         const aiConfig = await inquirer.prompt([
-            { type: 'list', name: 'model', message: 'Model:', choices: models },
-            { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v) => v.length > 0 || 'Required' },
+            { type: 'list', name: 'model', message: 'Model:', choices: AI_MODELS[providerId], default: DEFAULT_AI_MODEL[providerId], pageSize: 12 },
+            { type: 'password', name: 'apiToken', message: 'API token:', mask: '*', validate: (v) => v.trim().length > 0 || 'The API token is required' },
         ]);
         aiProviders.push({
-            provider: ai.provider,
+            provider: providerId,
             model: aiConfig.model,
-            apiToken: aiConfig.apiToken,
-            temperature: 0.7,
-            maxTokens: 4096,
+            apiToken: aiConfig.apiToken.trim(),
+            temperature: DEFAULT_TEMPERATURE,
+            maxTokens: DEFAULT_MAX_TOKENS,
             isDefault: true,
         });
+        console.log(theme.muted(`  Temperature ${DEFAULT_TEMPERATURE}, max tokens ${DEFAULT_MAX_TOKENS}. Tune them later with: plazbot agent ai-config <agentId>`));
     }
-    // Paso 7: Conectar canal
-    console.log(theme.bold('\n  Step 7/8: Connect channel'));
+    // Step 7: channels
+    console.log(theme.bold('\n  Step 7/8: Connect a channel'));
     let channels = [];
     const { addChannel } = await inquirer.prompt([{
             type: 'confirm',
             name: 'addChannel',
-            message: 'Connect a channel (WhatsApp, Instagram, Messenger)?',
+            message: 'Connect a channel now (WhatsApp, Instagram, Messenger, Telegram)?',
             default: false,
         }]);
     if (addChannel && workspaceId && apiKey) {
         channels = await connectChannelFlow({ zone, workspaceId, apiKey, dev: dev || false });
     }
     else if (addChannel) {
-        // Fallback manual si no hay credenciales para API
+        // Manual fallback when there are no credentials to call the API
         const wa = await inquirer.prompt([
-            { type: 'input', name: 'key', message: 'WhatsApp number (with country code):', validate: (v) => v.length > 0 || 'Required' },
-            { type: 'confirm', name: 'multianswer', message: 'Allow multiple answers?', default: false },
+            { type: 'input', name: 'phone', message: 'WhatsApp number with country code (e.g. +51912345678):', validate: validatePhone },
+            { type: 'confirm', name: 'multianswer', message: 'Allow multiple replies per message?', default: false },
         ]);
-        channels.push({ channel: 'whatsapp', key: wa.key, multianswer: wa.multianswer });
+        channels.push({ channel: 'whatsapp', key: normalizePhone(wa.phone), multianswer: wa.multianswer });
     }
-    // Paso 8: Ejemplos
+    // Step 8: examples
     console.log(theme.bold('\n  Step 8/8: Conversation examples'));
     const examples = [];
     const { addExamples } = await inquirer.prompt([{
             type: 'confirm',
             name: 'addExamples',
-            message: 'Add conversation examples?',
+            message: 'Add example conversations to guide the agent?',
             default: false,
         }]);
-    if (addExamples) {
-        let addMore = true;
-        while (addMore) {
-            const ex = await inquirer.prompt([
-                { type: 'input', name: 'user', message: 'User message:' },
-                { type: 'input', name: 'agent', message: 'Agent response:' },
-            ]);
-            examples.push({ value: `User: ${ex.user}\nAgent: ${ex.agent}`, color: 'blue' });
-            const { more } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another example?', default: false }]);
-            addMore = more;
-        }
+    let moreExamples = addExamples;
+    while (moreExamples) {
+        const ex = await inquirer.prompt([
+            { type: 'input', name: 'user', message: 'Customer message:', validate: (v) => v.trim().length > 0 || 'Required' },
+            { type: 'input', name: 'agent', message: 'Agent reply:', validate: (v) => v.trim().length > 0 || 'Required' },
+        ]);
+        examples.push({ value: `User: ${ex.user}\nAgent: ${ex.agent}`, color: 'blue' });
+        ({ more: moreExamples } = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another example?', default: false }]));
     }
-    // Armar config final (alineado con agent.config.schema.json del backend)
+    // Final config (aligned with the backend agent.config.schema.json)
     const config = {
-        name: basic.name,
+        name: basic.name.trim(),
         description: basic.description || '',
         prompt: basic.prompt,
-        buffer: basic.buffer,
+        buffer: Number(basic.buffer),
         zone,
         color: basic.color,
         useToolCalling,
@@ -598,18 +507,20 @@ export async function runAgentWizard(zone, workspaceId, apiKey, dev) {
     // Preview
     console.log(section('Configuration preview'));
     console.log(kvPair('Name', config.name));
-    console.log(kvPair('Prompt', config.prompt.substring(0, 80) + '...'));
+    console.log(kvPair('Prompt', config.prompt.length > 80 ? config.prompt.substring(0, 80) + '…' : config.prompt));
+    console.log(kvPair('Memory', `${config.buffer} messages`));
+    console.log(kvPair('Language', LANGUAGES.find(l => l.value === config.instructions.language)?.name || config.instructions.language));
     console.log(kvPair('Tool Calling', config.useToolCalling ? 'Enabled' : 'Disabled'));
     console.log(kvPair('Services', String(config.services.length)));
     console.log(kvPair('Actions', String(config.actions.length)));
-    console.log(kvPair('AI Provider', config.customAIConfig ? config.aiProviders[0]?.provider + ' / ' + config.aiProviders[0]?.model : 'Default (Plazbot)'));
+    console.log(kvPair('AI provider', config.customAIConfig ? `${config.aiProviders[0]?.provider} / ${config.aiProviders[0]?.model}` : 'Platform default (Plazbot)'));
     if (config.channels.length > 0) {
         config.channels.forEach((ch, i) => {
             console.log(kvPair(`Channel ${i + 1} (${ch.channel})`, ch.key));
         });
     }
     else {
-        console.log(kvPair('Channels', 'Not configured'));
+        console.log(kvPair('Channels', 'Not connected'));
     }
     console.log();
     return config;