plazbot-cli 0.3.7 → 0.4.1

package/src/commands/agent/wizard.ts

@@ -1,756 +0,0 @@
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import axios from 'axios';
-import ora from 'ora';
-import { theme, section, kvPair } from '../../utils/ui.js';
-
-interface AgentConfig {
-  name: string;
-  description?: string;
-  prompt: string;
-  buffer: number;
-  zone: string;
-  color: string;
-  useToolCalling: boolean;
-  customAIConfig: boolean;
-  aiProviders: AIProvider[];
-  instructions: AgentInstructions;
-  person: AgentPerson;
-  fallbacks: AgentFallbacks;
-  services: AgentService[];
-  actions: AgentAction[];
-  channels: AgentChannel[];
-  examples: AgentExample[];
-  tags: string[];
-}
-
-interface AIProvider {
-  provider: string;
-  model: string;
-  apiToken: string;
-  temperature: number;
-  maxTokens: number;
-  isDefault: boolean;
-}
-
-interface AgentInstructions {
-  tone: string;
-  style: string;
-  personality: string;
-  objective: string;
-  language: string;
-  emojis: boolean;
-}
-
-interface AgentPerson {
-  name: string;
-  role: string;
-  speaksInFirstPerson: boolean;
-}
-
-interface AgentFallbacks {
-  noAnswer: string;
-  serviceError: string;
-  doNotUnderstand: string;
-}
-
-interface AgentService {
-  intent: string;
-  reference: string;
-  enabled: boolean;
-  method: string;
-  endpoint: string;
-  requiredFields: { name: string; type: string; description: string; promptHint: string }[];
-  headers: Record<string, string>;
-  bodyTemplate: Record<string, string>;
-  responseMapping: Record<string, string>;
-  responseMessage: string;
-  responseConditions: { condition: string; message: string }[];
-}
-
-interface AgentAction {
-  intent: string;
-  reference: string;
-  enabled: boolean;
-  requiredFields: { name: string; type: string; description: string; promptHint: string }[];
-  responseMessage: string;
-  action: { type: string; value: string }[];
-}
-
-interface AgentChannel {
-  channel: string;
-  key: string;
-  multianswer: boolean;
-}
-
-interface AgentExample {
-  value: string;
-  color: string;
-}
-
-const MODELS: Record<string, string[]> = {
-  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'],
-};
-
-const COLORS = ['blue', 'green', 'orange', 'gray', 'white'];
-
-export interface WizardContext {
-  zone: string;
-  workspaceId: string;
-  apiKey: string;
-  dev: boolean;
-}
-
-function getBaseUrl(zone: string, dev: boolean): string {
-  if (dev) return 'http://localhost:5090';
-  return zone === 'EU' ? 'https://apieu.plazbot.com' : 'https://api.plazbot.com';
-}
-
-const CHANNEL_CHOICES = [
-  { name: 'WhatsApp', value: 'whatsapp' },
-  { name: 'WhatsApp Business', value: 'whatsapp_business' },
-  { name: 'Instagram', value: 'instagram' },
-  { name: 'Messenger', value: 'facebook' },
-  { name: 'Telegram', value: 'telegram' },
-];
-
-const CHANNEL_AGENT_MAP: Record<string, string> = {
-  whatsapp: 'whatsapp',
-  whatsapp_business: 'whatsapp',
-  instagram: 'instagram',
-  facebook: 'messenger',
-  telegram: 'telegram',
-};
-
-function getIntegrationLabel(ig: any): string {
-  if (ig.type === 'whatsapp') {
-    return ig.aliasName
-      ? `${ig.aliasName} (${ig.cellphoneNumberFormat || ig.cellphoneNumber || ''})`
-      : ig.cellphoneNumberFormat || ig.cellphoneNumber || ig.id;
-  }
-  return ig.aliasName || ig.srcName || ig.id;
-}
-
-function getIntegrationKey(ig: any): string {
-  return ig.aliasName || ig.srcName || ig.id;
-}
-
-async function fetchWorkspaceIntegrations(baseUrl: string, workspaceId: string, headers: any): Promise<any[]> {
-  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 [];
-  }
-}
-
-async function activateIntegration(baseUrl: string, workspaceId: string, integrationId: string, headers: any): Promise<boolean> {
-  try {
-    const res = await axios.post(
-      `${baseUrl}/api/workspace/${workspaceId}/integrations/${integrationId}/activate`,
-      { isActive: true },
-      { headers }
-    );
-    return res.data?.success === true;
-  } catch {
-    return false;
-  }
-}
-
-export async function connectChannelFlow(ctx: WizardContext): Promise<AgentChannel[]> {
-  const channels: AgentChannel[] = [];
-  const baseUrl = getBaseUrl(ctx.zone, ctx.dev);
-  const headers = {
-    'Authorization': `Bearer ${ctx.apiKey}`,
-    'x-workspace-id': ctx.workspaceId,
-    'Content-Type': 'application/json',
-  };
-
-  let addMore = true;
-  while (addMore) {
-    const { channelType } = await (inquirer as any).prompt([{
-      type: 'list',
-      name: 'channelType',
-      message: 'Which channel do you want to connect?',
-      choices: CHANNEL_CHOICES,
-    }]);
-
-    const channelLabel = CHANNEL_CHOICES.find(c => c.value === channelType)?.name || channelType;
-    const targetType = channelType === 'whatsapp_business' ? 'whatsapp' : channelType;
-
-    // Cargar integraciones existentes del tipo seleccionado
-    const loadSpinner = ora({ text: chalk.gray('Loading integrations...'), spinner: 'dots', color: 'green' }).start();
-    const allIntegrations = await fetchWorkspaceIntegrations(baseUrl, ctx.workspaceId, headers);
-    const existing = allIntegrations.filter((ig: any) => ig.type === targetType);
-    loadSpinner.stop();
-
-    let selectedIntegration: any = null;
-
-    if (existing.length > 0) {
-      // Mostrar integraciones existentes + opcion de agregar nueva
-      const choices = existing.map((ig: any) => ({
-        name: `${getIntegrationLabel(ig)}`,
-        value: ig.id,
-      }));
-      choices.push(new (inquirer as any).Separator());
-      choices.push({ name: chalk.hex('#4ade80')('+ Add a new one (generate link)'), value: '__new__' });
-
-      const { selected } = await (inquirer as any).prompt([{
-        type: 'list',
-        name: 'selected',
-        message: `Available ${channelLabel} integrations:`,
-        choices,
-      }]);
-
-      if (selected !== '__new__') {
-        // Selecciono una existente
-        selectedIntegration = existing.find((ig: any) => 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.'));
-          }
-        }
-
-        channels.push({
-          channel: CHANNEL_AGENT_MAP[channelType],
-          key: getIntegrationKey(selectedIntegration),
-          multianswer: false,
-        });
-        console.log(chalk.hex('#4ade80')(`  Channel linked: ${label}`));
-      }
-    }
-
-    // Si no hay existentes o eligio "Agregar nuevo" → generar link de onboarding
-    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'}`));
-        } 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();
-          console.log('  ' + chalk.hex('#22d3ee')(shortUrl));
-          console.log();
-          console.log(chalk.hex('#4CAF50')('  ─'.repeat(32)));
-          console.log();
-
-          // Guardar IDs actuales para detectar nuevos
-          const prevIds = new Set(allIntegrations.map((i: any) => 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: any = null;
-          let skipped = false;
-
-          // Escuchar Enter para saltar
-          const skipPromise = new Promise<void>(resolve => {
-            const onData = (data: Buffer) => {
-              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);
-          });
-
-          for (let i = 0; i < MAX_POLLS; i++) {
-            await Promise.race([
-              new Promise(r => setTimeout(r, POLL_INTERVAL)),
-              skipPromise,
-            ]);
-            if (skipped) break;
-            try {
-              const freshIntegrations = await fetchWorkspaceIntegrations(baseUrl, ctx.workspaceId, headers);
-              const newOnes = freshIntegrations.filter((ig: any) => !prevIds.has(ig.id));
-              if (newOnes.length > 0) {
-                const match = newOnes.find((ig: any) => ig.type === targetType);
-                detected = match || newOnes[0];
-                break;
-              }
-            } catch {}
-            const elapsed = Math.floor(((i + 1) * POLL_INTERVAL) / 1000);
-            pollSpinner.text = chalk.gray(`Waiting for connection... ${elapsed}s (Enter to skip)`);
-          }
-
-          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.'));
-            }
-
-            channels.push({
-              channel: CHANNEL_AGENT_MAP[channelType],
-              key: getIntegrationKey(detected),
-              multianswer: false,
-            });
-            console.log(chalk.hex('#4ade80')('  Channel linked successfully.'));
-          } else {
-            pollSpinner.warn(chalk.hex('#FFA726')(skipped ? 'Skipped.' : 'Timeout: no connection detected.'));
-            const { action } = await (inquirer as any).prompt([{
-              type: 'list', name: 'action',
-              message: 'What would you like to do?',
-              choices: [
-                { name: 'Enter ID manually', value: 'manual' },
-                { name: 'Skip', value: 'skip' },
-              ],
-            }]);
-            if (action === 'manual') {
-              const { key } = await (inquirer as any).prompt([
-                { type: 'input', name: 'key', message: `${channelLabel} channel ID/number:`, validate: (v: string) => v.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 });
-            }
-          }
-        }
-      } catch (err) {
-        spinner.fail(chalk.hex('#EF5350')(`Error: ${err instanceof Error ? err.message : err}`));
-      }
-    }
-
-    const { more } = await (inquirer as any).prompt([{ type: 'confirm', name: 'more', message: 'Connect another channel?', default: false }]);
-    addMore = more;
-  }
-
-  return channels;
-}
-
-export async function runAgentWizard(zone: string, workspaceId?: string, apiKey?: string, dev?: boolean): Promise<AgentConfig> {
-  console.log(section('Create new AI agent'));
-  console.log(theme.muted('  Answer the following questions to configure your agent.\n'));
-
-  // Paso 1: Informacion basica
-  console.log(theme.bold('\n  Step 1/8: Basic information'));
-  const basic = await (inquirer as any).prompt([
-    {
-      type: 'input',
-      name: 'name',
-      message: 'Agent name:',
-      validate: (v: string) => v.length > 0 || 'Name is required',
-    },
-    {
-      type: 'input',
-      name: 'description',
-      message: 'Short description:',
-      default: '',
-    },
-    {
-      type: 'input',
-      name: 'prompt',
-      message: 'System prompt (main instructions):',
-      default: 'You are a friendly and professional virtual assistant.',
-    },
-    {
-      type: 'number',
-      name: 'buffer',
-      message: 'Conversation buffer (3-20 messages):',
-      default: 5,
-      validate: (v: number) => (v >= 3 && v <= 20) || 'Must be between 3 and 20',
-    },
-    {
-      type: 'list',
-      name: 'color',
-      message: 'Agent color:',
-      choices: COLORS,
-      default: 'blue',
-    },
-  ]);
-
-  // Paso 2: Personalidad
-  console.log(theme.bold('\n  Step 2/8: Personality and instructions'));
-  const personality = await (inquirer as any).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,
-    },
-  ]);
-
-  // Paso 3: Persona
-  console.log(theme.bold('\n  Step 3/8: Agent identity'));
-  const person = await (inquirer as any).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,
-    },
-  ]);
-
-  // Paso 4: Fallbacks
-  console.log(theme.bold('\n  Step 4/8: Fallback messages'));
-  const fallbacks = await (inquirer as any).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?',
-    },
-  ]);
-
-  // Paso 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'));
-  const { useToolCalling } = await (inquirer as any).prompt([
-    {
-      type: 'confirm',
-      name: 'useToolCalling',
-      message: 'Enable Tool Calling?',
-      default: true,
-    },
-  ]);
-
-  // Servicios (API calls)
-  const services: AgentService[] = [];
-  if (useToolCalling) {
-    const { addServices } = await (inquirer as any).prompt([{
-      type: 'confirm',
-      name: 'addServices',
-      message: 'Add external services (API calls)?',
-      default: false,
-    }]);
-
-    if (addServices) {
-      let addMore = true;
-      while (addMore) {
-        console.log(theme.muted('\n  New service:'));
-        const svc = await (inquirer as any).prompt([
-          { type: 'input', name: 'intent', message: 'Service name/intent:', validate: (v: string) => 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: string) => v.length > 0 || 'Required' },
-          { type: 'input', name: 'responseMessage', message: 'Response message:', default: '' },
-        ]);
-
-        // Required fields
-        const fields: AgentService['requiredFields'] = [];
-        const { addFields } = await (inquirer as any).prompt([{
-          type: 'confirm', name: 'addFields',
-          message: 'Add required fields?', default: false,
-        }]);
-        if (addFields) {
-          let moreFields = true;
-          while (moreFields) {
-            const field = await (inquirer as any).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 as any).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 as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another service?', default: false }]);
-        addMore = more;
-      }
-    }
-  }
-
-  // Acciones
-  const actions: AgentAction[] = [];
-  if (useToolCalling) {
-    const { addActions } = await (inquirer as any).prompt([{
-      type: 'confirm',
-      name: 'addActions',
-      message: 'Add actions (tag, stage, assign agent)?',
-      default: false,
-    }]);
-
-    if (addActions) {
-      let addMore = true;
-      while (addMore) {
-        console.log(theme.muted('\n  New action:'));
-        const act = await (inquirer as any).prompt([
-          { type: 'input', name: 'intent', message: 'Action name/intent:', validate: (v: string) => 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 as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another action?', default: false }]);
-        addMore = more;
-      }
-    }
-  }
-
-  // Paso 6: AI Provider
-  console.log(theme.bold('\n  Step 6/8: AI provider'));
-  const { configureAI } = await (inquirer as any).prompt([{
-    type: 'confirm',
-    name: 'configureAI',
-    message: 'Configure a custom AI provider?',
-    default: false,
-  }]);
-
-  const aiProviders: AIProvider[] = [];
-  if (configureAI) {
-    const ai = await (inquirer as any).prompt([
-      { type: 'list', name: 'provider', message: 'Provider:', choices: ['openai', 'claude', 'gemini'] },
-    ]);
-    const models = MODELS[ai.provider] || MODELS.openai;
-    const aiConfig = await (inquirer as any).prompt([
-      { type: 'list', name: 'model', message: 'Model:', choices: models },
-      { type: 'password', name: 'apiToken', message: 'API Token:', mask: '*', validate: (v: string) => v.length > 0 || 'Required' },
-    ]);
-
-    aiProviders.push({
-      provider: ai.provider,
-      model: aiConfig.model,
-      apiToken: aiConfig.apiToken,
-      temperature: 0.7,
-      maxTokens: 4096,
-      isDefault: true,
-    });
-  }
-
-  // Paso 7: Conectar canal
-  console.log(theme.bold('\n  Step 7/8: Connect channel'));
-  let channels: AgentChannel[] = [];
-  const { addChannel } = await (inquirer as any).prompt([{
-    type: 'confirm',
-    name: 'addChannel',
-    message: 'Connect a channel (WhatsApp, Instagram, Messenger)?',
-    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
-    const wa = await (inquirer as any).prompt([
-      { type: 'input', name: 'key', message: 'WhatsApp number (with country code):', validate: (v: string) => v.length > 0 || 'Required' },
-      { type: 'confirm', name: 'multianswer', message: 'Allow multiple answers?', default: false },
-    ]);
-    channels.push({ channel: 'whatsapp', key: wa.key, multianswer: wa.multianswer });
-  }
-
-  // Paso 8: Ejemplos
-  console.log(theme.bold('\n  Step 8/8: Conversation examples'));
-  const examples: AgentExample[] = [];
-  const { addExamples } = await (inquirer as any).prompt([{
-    type: 'confirm',
-    name: 'addExamples',
-    message: 'Add conversation examples?',
-    default: false,
-  }]);
-
-  if (addExamples) {
-    let addMore = true;
-    while (addMore) {
-      const ex = await (inquirer as any).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 as any).prompt([{ type: 'confirm', name: 'more', message: 'Add another example?', default: false }]);
-      addMore = more;
-    }
-  }
-
-  // Armar config final (alineado con agent.config.schema.json del backend)
-  const config: AgentConfig = {
-    name: basic.name,
-    description: basic.description || '',
-    prompt: basic.prompt,
-    buffer: basic.buffer,
-    zone,
-    color: basic.color,
-    useToolCalling,
-    customAIConfig: configureAI,
-    aiProviders,
-    instructions: {
-      tone: personality.tone,
-      style: personality.style,
-      personality: personality.personality,
-      objective: personality.objective,
-      language: personality.language,
-      emojis: personality.useEmojis,
-    },
-    person: {
-      name: person.name,
-      role: person.role,
-      speaksInFirstPerson: person.firstPerson,
-    },
-    fallbacks: {
-      noAnswer: fallbacks.noAnswer,
-      serviceError: fallbacks.serviceError,
-      doNotUnderstand: fallbacks.misunderstanding,
-    },
-    services,
-    actions,
-    channels,
-    examples,
-    tags: [],
-  };
-
-  // Preview
-  console.log(section('Configuration preview'));
-  console.log(kvPair('Name', config.name));
-  console.log(kvPair('Prompt', config.prompt.substring(0, 80) + '...'));
-  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)'));
-  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();
-
-  return config;
-}