Agente de IA

import { Agent } from 'plazbot';

const bot = new Agent({
  workspaceId: "[YOUR_WORKSPACE_ID]",
  apiKey: "[YOUR_API_KEY]",
  zone: "LA" // Use "EU" for Europe
});

    const agent = await bot.addAgent(config);
    const agentId = agent.agentId;

    const agentUpdated = await bot.updateAgent(`agentId`, config);

{
  "name": "Sales Clinic",
  "description": "Virtual Agent IA assistant of the Dental Clinic Smiles",
  "prompt": "You are Máximo, a professional virtual assistant for Smiles Dental Clinic. Help patients with appointments, general information, and guide them through our services. Always maintain a professional yet friendly tone.",
  "zone": "LA",
  "buffer": 15,
  "color": "blue",
  "question": "How can I help you today?",
  "timezone": "America/Lima",
  "enable": true,
  "tags": [
    "health",
    "dentistry",
    "ia",
    "plazbot"
  ],
  "showInChat": false,
  "enableWidget": true,
  "darkWidget": true,
  "nameWidget": "Dental Assistant",
  "initialShowWidget": true,
  "examples": [
    { "value": "How to schedule an appointment?", "color": "green" },
    { "value": "What are your office hours?", "color": "blue" },
    { "value": "Do you accept insurance?", "color": "orange" },
    { "value": "Emergency contact information", "color": "gray" },
    { "value": "Location and directions", "color": "white" }
  ],
  "instructions": {
    "tone": "professional",
    "style": "short answers",
    "personality": "friendly",
    "objective": "help with clarity",
    "language": "es-419",
    "emojis": false,
    "preferredFormat": "plain text",
    "maxWords": 80,
    "avoidTopics": [
      "laboratory costs",
      "external claims",
      "specific medical diagnoses"
    ],
    "respondOnlyIfKnows": true,
    "maintainToneBetweenMessages": true,
    "greeting": "Hello, I am Máximo, your virtual assistant from Smiles Dental Clinic. How can I help you today?"
  },
  "person": {
    "name": "Máximo",
    "role": "Virtual customer service assistant",
    "speaksInFirstPerson": true,
    "isHuman": false
  },
  "fallbacks": {
    "noAnswer": "Sorry, I don't have information on that topic. Let me connect you with one of our specialists.",
    "serviceError": "There was a problem processing your request. Please try again later or contact us directly.",
    "doNotUnderstand": "Could you please repeat it in another way? I want to make sure I help you correctly."
  },
  "rules": {
    "doNotMentionPrices": false,
    "doNotDiagnose": true,
    "doNotRespondOutsideHours": "Our office hours are Monday to Saturday, from 8am to 6pm. For emergencies, please call our emergency line."
  },
  "channels": [
    {
      "channel": "whatsapp",
      "key": "+51987654321",
      "multianswer": false
    },
    {
      "channel": "telegram",
      "key": "smiles_clinic_bot",
      "multianswer": true
    }
  ],
  "services": [
    {
      "intent": "schedule_appointment",
      "reference": "Service for scheduling patient appointments at the dental clinic",
      "enabled": true,
      "method": "POST",
      "tags": ["appointment", "scheduling"],
      "endpoint": "https://api.smilesclinic.com/v1/appointments/schedule",
      "requiredFields": [
        {
          "name": "patient_name",
          "description": "Full name of the patient who wants to schedule the appointment",
          "promptHint": "Could you please provide your full name?",
          "type": "string"
        },
        {
          "name": "email",
          "description": "Patient's email address for appointment confirmation",
          "promptHint": "What's your email address for the appointment confirmation?",
          "type": "email"
        },
        {
          "name": "phone",
          "description": "Patient's phone number for contact",
          "promptHint": "Could you provide your phone number?",
          "type": "phone"
        },
        {
          "name": "preferred_date",
          "description": "Preferred date and time for the appointment",
          "promptHint": "What date and time would work best for your appointment?",
          "type": "datetime"
        },
        {
          "name": "service_type",
          "description": "Type of dental service needed",
          "promptHint": "What type of dental service do you need? (cleaning, consultation, etc.)",
          "type": "string"
        }
      ],
      "headers": {
        "Authorization": "Bearer {{clinic_api_key}}",
        "Content-Type": "application/json",
        "X-Clinic-ID": "smiles_001"
      },
      "bodyTemplate": {
        "patient": {
          "name": "{{patient_name}}",
          "email": "{{email}}",
          "phone": "{{phone}}"
        },
        "appointment": {
          "datetime": "{{preferred_date|format('yyyy-MM-dd HH:mm')}}",
          "service": "{{service_type}}",
          "timezone": "America/Lima"
        }
      },
      "bodySchema": {
        "patient_name": "string",
        "email": "string",
        "preferred_date": "date",
        "service_type": "string"
      },
      "responseMapping": {
        "confirmation_id": "$.data.appointment.id",
        "scheduled_date": "$.data.appointment.datetime",
        "status": "$.status",
        "doctor_name": "$.data.appointment.doctor.name",
        "conflict_reason": "$.error.reason"
      },
      "responseMessage": "Your appointment has been successfully scheduled for {{scheduled_date}} with Dr. {{doctor_name}}",
      "responseConditions": [
        {
          "condition": "$.status == 'confirmed'",
          "message": "¡Perfect! Your appointment has been confirmed for {{scheduled_date}} with Dr. {{doctor_name}}. We'll send you a reminder 24 hours before. Confirmation ID: {{confirmation_id}}",
          "nextService": "send_appointment_reminder"
        },
        {
          "condition": "$.status == 'conflict'",
          "message": "Sorry, that time slot is not available. {{conflict_reason}}. Would you like me to suggest other available times?",
          "nextService": "suggest_alternative_times"
        },
        {
          "condition": "$.status == 'error' && $.error.code == 'invalid_email'",
          "message": "The email address provided seems invalid. Could you please verify your email address?",
          "nextService": "verify_contact_info"
        },
        {
          "condition": "$.status == 'error' && $.error.code == 'past_date'",
          "message": "I cannot schedule appointments for past dates. Could you please choose a future date?"
        },
        {
          "condition": "$.status == 'pending'",
          "message": "Your appointment request is being reviewed. We'll contact you within 24 hours to confirm availability and finalize the details."
        }
      ],
      "action": "conversar_humano"
    },
    {
      "intent": "check_insurance",
      "reference": "Service to verify patient insurance coverage and benefits",
      "enabled": true,
      "method": "GET",
      "tags": ["insurance", "verification"],
      "endpoint": "https://api.smilesclinic.com/v1/insurance/verify",
      "requiredFields": [
        {
          "name": "insurance_provider",
          "description": "Name of the insurance company",
          "promptHint": "What's your insurance provider name?",
          "type": "string"
        },
        {
          "name": "policy_number",
          "description": "Insurance policy or member ID number",
          "promptHint": "Could you provide your policy or member ID number?",
          "type": "string"
        }
      ],
      "headers": {
        "Authorization": "Bearer {{insurance_api_key}}",
        "Content-Type": "application/json"
      },
      "responseMapping": {
        "coverage_status": "$.data.coverage.status",
        "deductible": "$.data.coverage.deductible",
        "copay": "$.data.coverage.copay",
        "covered_services": "$.data.coverage.services"
      },
      "responseMessage": "Your insurance verification is complete. Coverage status: {{coverage_status}}",
      "responseConditions": [
        {
          "condition": "$.data.coverage.status == 'active'",
          "message": "Great news! Your insurance is active. Your copay is ${{copay}} and your remaining deductible is ${{deductible}}. Covered services include: {{covered_services}}."
        },
        {
          "condition": "$.data.coverage.status == 'inactive'",
          "message": "It appears your insurance policy is not currently active. Please contact your insurance provider or we can discuss our self-pay options."
        },
        {
          "condition": "$.data.coverage.status == 'not_found'",
          "message": "I couldn't find your policy in our system. Please verify your insurance information or contact us directly for assistance."
        }
      ]
    }
  ],
  "actions": [
    {
      "intent": "assign_urgent_tag",
      "reference": "Tags patients as urgent when they mention emergency dental situations",
      "tags": ["emergency", "urgent"],
      "enabled": true,
      "responseMessage": "I've marked your case as urgent and notified our emergency team.",
      "responseJson": false,
      "action": [
        {
          "type": "action.tag",
          "value": "urgent_case"
        },
        {
          "type": "action.asign",
          "value": "emergency@smilesclinic.com"
        }
      ]
    },
    {
      "intent": "schedule_follow_up",
      "reference": "Automatically schedules follow-up appointments and assigns appropriate case management",
      "tags": ["follow-up", "scheduling"],
      "enabled": true,
      "responseMessage": "Your follow-up has been scheduled and assigned to our treatment coordinator.",
      "responseJson": false,
      "action": [
        {
          "type": "action.stage",
          "value": "follow_up_scheduled"
        },
        {
          "type": "action.segmentation",
          "value": "post_treatment_care"
        }
      ]
    },
    {
      "intent": "end_consultation",
      "reference": "Ends the AI consultation when the patient no longer needs assistance",
      "tags": ["consultation", "end"],
      "enabled": true,
      "responseMessage": "Thank you for contacting Smiles Dental Clinic. Have a great day!",
      "responseJson": false,
      "action": [
        {
          "type": "action.agentShutDown",
          "value": "true"
        }
      ]
    }
  ]
}

{
  "responseIA": true,
  "responseJson": false
}

{
  "responseIA": false,
  "responseJson": false,
  "responseMessage": "Solicitud procesada correctamente."
}

{
  "responseIA": false,
  "responseJson": true,
  "responseMessage": "Proceso completado"
}

"channels": [
  { "channel": "whatsapp", "key": "123456789" },
  { "channel": "telegram", "key": "@mi_bot" },
  { "channel": "messenger", "key": "page_id_123" }
]

const response = await bot.onMessage({
  agentId: "agentId",
  question: "Can you give me a summary of the new Meta WhatsApp prices?",
  sessionId: "2aff0c11-434f-4d7c-a325-697128bb8a20",
  file: "https://.../archivo.pdf", // 
  multipleAnswers: true // Optional
});

console.log("💬 IA Response:", respuesta);

{
  "success": true,
  "answers": [
    "Beneficio 1: Acceso exclusivo...",
    "Beneficio 2: Soporte personalizado...",
    "Beneficio 3: Capacitación mensual..."
  ],
  "fileName": ["Contrato_socio_plazbot.pdf"]
}

    const agents = await bot.getAgents();
    console.log("🧠 Agents:", agents);

    const agentById = await bot.getAgentById({ id: agentId });
    console.log("📌 Agent by ID:", agentById);

    // Delete Agent
    await bot.deleteAgent({
      id: agentId
    });

const fileResult = await bot.addFile({
  agentId: "agent_123",
  file: fileBuffer, // Buffer del archivo
  fileName: "manual_usuario.pdf"
});

console.log("📄 File added:", fileResult);

const files = await bot.getFiles({
  agentId: "agent_123"
});

console.log("📂 Agent files:", files);

await bot.deleteFile({
  agentId: "agent_123",
  fileId: "file_456"
});

try {
  const response = await bot.onMessage({
    agentId: "agent_123",
    question: "¿Cuáles son los horarios?",
    sessionId: "session_456"
  });
  
  console.log("✅ Success:", response);
} catch (error) {
  console.error("❌ Error:", error.message);
  
  // Diferentes tipos de errores
  if (error.status === 401) {
    console.log("🔑 Error de autenticación - Revisa tu API Key");
  } else if (error.status === 404) {
    console.log("🔍 Agente no encontrado");
  } else if (error.status === 429) {
    console.log("⏱️ Límite de rate exceeded - Espera antes de reintentar");
  } else {
    console.log("🚨 Error del servidor:", error);
  }
}

// ✅ Correcto - Mantén sessionId consistente por conversación
const sessionId = uuidv4(); // Genera una vez por conversación
await bot.onMessage({ agentId, question: "Hola", sessionId });
await bot.onMessage({ agentId, question: "¿Precios?", sessionId }); // Mismo sessionId

// ✅ Correcto - Reutiliza la instancia del bot
const bot = new Agent({ workspaceId, apiKey, zone: "LA" });

// Úsala múltiples veces
await bot.onMessage({ agentId: "agent1", question: "...", sessionId: "..." });
await bot.onMessage({ agentId: "agent2", question: "...", sessionId: "..." });

// Para usuarios en América Latina
const botLA = new Agent({
  workspaceId: "[YOUR_WORKSPACE_ID]",
  apiKey: "[YOUR_API_KEY]",
  zone: "LA" // Menor latencia desde América
});

// Para usuarios en Europa
const botEU = new Agent({
  workspaceId: "[YOUR_WORKSPACE_ID]",
  apiKey: "[YOUR_API_KEY]",
  zone: "EU" // Menor latencia desde Europa
});

async function sendMultipleMessages(messages) {
  for (const message of messages) {
    try {
      const response = await bot.onMessage(message);
      console.log(response);
      
      // Pausa entre mensajes para evitar rate limiting
      await new Promise(resolve => setTimeout(resolve, 100));
    } catch (error) {
      if (error.status === 429) {
        console.log("Rate limit detectado, esperando...");
        await new Promise(resolve => setTimeout(resolve, 5000));
        // Opcionalmente reintentar
      }
      console.error("Error:", error.message);
    }
  }
}

import { Agent } from 'plazbot';
import { v4 as uuidv4 } from 'uuid';

class PlazbotChatBot {
  private bot: Agent;
  private sessionId: string;
  
  constructor(workspaceId: string, apiKey: string, zone: "LA" | "EU" = "LA") {
    this.bot = new Agent({ workspaceId, apiKey, zone });
    this.sessionId = uuidv4();
  }
  
  async chat(agentId: string, message: string, file?: string) {
    try {
      const response = await this.bot.onMessage({
        agentId,
        question: message,
        sessionId: this.sessionId,
        file,
        multipleAnswers: false
      });
      
      return {
        success: true,
        message: response.answer,
        sessionId: this.sessionId
      };
    } catch (error) {
      return {
        success: false,
        error: error.message,
        sessionId: this.sessionId
      };
    }
  }
  
  async resetSession() {
    this.sessionId = uuidv4();
  }
}

// Uso
const chatBot = new PlazbotChatBot("workspace_123", "api_key_456", "LA");

const response1 = await chatBot.chat("agent_123", "Hola, ¿cómo estás?");
console.log(response1.message);

const response2 = await chatBot.chat("agent_123", "¿Cuáles son sus servicios?");
console.log(response2.message);

import express from 'express';
import { Agent } from 'plazbot';

const app = express();
const bot = new Agent({
  workspaceId: process.env.PLAZBOT_WORKSPACE_ID!,
  apiKey: process.env.PLAZBOT_API_KEY!,
  zone: "LA"
});

app.post('/webhook/whatsapp', async (req, res) => {
  const { message, from, sessionId } = req.body;
  
  try {
    const response = await bot.onMessage({
      agentId: "whatsapp_agent_123",
      question: message,
      sessionId: sessionId || from, // Usa el número como sessionId
    });
    
    // Envía respuesta de vuelta a WhatsApp
    res.json({
      success: true,
      reply: response.answer
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

{
  "actions": [
    {
      "intent": "conversar_humano",
      "reference": "Información cuando un usuario quiere hablar con un Agente humano.",
      "tags": ["conversacion", "humano", "agente"],
      "enabled": true,
      "responseMessage": "Por favor, espera un momento mientras te conectamos con un agente humano.",
      "responseIA": false,
      "responseJson": false,
      "action": [
        {
          "type": "action.asign",
          "value": "soporte@empresa.com"
        },
        {
          "type": "action.stage",
          "value": "agendado"
        },
        {
          "type": "action.agentShutDown",
          "value": "true"
        },
        {
          "type": "action.segmentation",
          "value": "clientes_vip"
        },
        {
          "type": "action.tag",
          "value": "requiere_atencion_humana"
        }
      ]
    },
    {
      "intent": "marcar_como_lead",
      "reference": "Cuando un usuario muestra interés comercial o solicita información de ventas.",
      "tags": ["ventas", "lead", "comercial"],
      "enabled": true,
      "responseIA": true,
      "responseJson": false,
      "action": [
        {
          "type": "action.tag",
          "value": "lead_calificado"
        },
        {
          "type": "action.stage",
          "value": "prospecto"
        },
        {
          "type": "action.segmentation",
          "value": "interesados_ventas"
        }
      ]
    }
  ]
}

# .env
PLAZBOT_WORKSPACE_ID=your_workspace_id_here
PLAZBOT_API_KEY=your_api_key_here
PLAZBOT_ZONE=LA # o EU

# Para diferentes entornos
NODE_ENV=development # o production

interface BotConfig {
  workspaceId: string;
  apiKey: string;
  zone: "LA" | "EU";
}

const configs: Record<string, BotConfig> = {
  development: {
    workspaceId: process.env.DEV_WORKSPACE_ID!,
    apiKey: process.env.DEV_API_KEY!,
    zone: "LA"
  },
  production: {
    workspaceId: process.env.PROD_WORKSPACE_ID!,
    apiKey: process.env.PROD_API_KEY!,
    zone: "LA"
  }
};

const bot = new Agent(configs[process.env.NODE_ENV || 'development']);

// ❌ SDK v1 (Obsoleto)
const plazbot = require('plazbot-v1');
const response = await plazbot.send(agentId, message);

// ✅ SDK v2 (Actual)
import { Agent } from 'plazbot';
const bot = new Agent({ workspaceId, apiKey, zone: "LA" });
const response = await bot.onMessage({ agentId, question: message, sessionId });