Channels API

import { Channels } from 'lua-cli';

// Send a free-form message on any connected channel
await Channels.send({
  channel: 'whatsapp',
  to: { userId: 'user_123' },
  text: 'Your order has shipped! 📦'
});

// Send an email
await Channels.email.send({
  to: { email: '[email protected]' },
  subject: 'Order confirmation',
  text: 'Thanks for your order!'
});

// Re-open a closed WhatsApp window with an approved template
await Channels.whatsapp.sendTemplate({
  to: { phoneNumber: '+14155552671' },
  templateName: 'order_update',
  languageCode: 'en_US',
  messageContext: 'Told the customer their order shipped'
});

Channels.send(input: ChannelSendInput): Promise<ChannelSendOutput>

Channels.email.send(input: EmailSendInput): Promise<ChannelSendOutput>

await Channels.email.send({
  to: { email: '[email protected]' },
  subject: 'Your invoice',
  html: '<h1>Invoice #12345</h1><p>Total: $99.00</p>',
  cc: ['[email protected]'],
  attachments: [
    {
      filename: 'invoice-12345.pdf',
      contentType: 'application/pdf',
      url: 'https://files.example.com/invoice-12345.pdf'
    }
  ]
});

Channels.whatsapp.sendTemplate(input: WhatsAppTemplateSendInput): Promise<ChannelSendOutput>

await Channels.whatsapp.sendTemplate({
  to: { phoneNumber: '+14155552671' },
  templateName: 'appointment_reminder',
  languageCode: 'en_US',
  components: [
    { type: 'BODY', parameters: [{ type: 'text', text: 'Tuesday at 3pm' }] }
  ],
  messageContext: 'Reminded the customer about their Tuesday 3pm appointment'
});

interface ChannelSendOutput {
  delivered: boolean;     // the channel accepted the message for delivery
  persisted: boolean;     // the message was recorded to the agent's conversation thread
  queued?: boolean;       // WhatsApp only: deferred until the recipient re-engages
  userId?: string;        // the Lua user the message was recorded against
  identifier?: string;    // the channel-native recipient (phone / email / etc.)
  messageId?: string;     // provider message ID, where available
  warning?: string;       // set when delivered but not persisted
}

try {
  const result = await Channels.send({
    channel: 'whatsapp',
    to: { userId: 'user_123' },
    text: 'Quick update for you!'
  });

  if (result.queued) {
    // Window closed — message will deliver when the user replies
    console.log('Queued; will deliver on re-engagement');
  } else if (!result.persisted) {
    console.warn('Delivered but not recorded:', result.warning);
  }
} catch (err) {
  // Rejected — e.g. unconfigured channel, invalid recipient, closed-window 'fail'
  console.error('Send failed:', err.message);
}

type ChannelSendChannel =
  | 'whatsapp' | 'sms' | 'email' | 'webchat'
  | 'teams' | 'instagram' | 'messenger';

interface ChannelSendTarget {
  userId?: string;       // any channel
  phoneNumber?: string;  // whatsapp / sms (cold start)
  email?: string;        // email (cold start)
}

interface ChannelSendOptions {
  channelIdentifier?: string;
  whatsapp?: { onClosedWindow?: 'queue' | 'fail' };
}

interface ChannelSendInput {
  channel: ChannelSendChannel;
  to: ChannelSendTarget;
  text: string;
  options?: ChannelSendOptions;
}

interface WhatsAppTemplateSendInput {
  to: { userId?: string; phoneNumber?: string };
  templateName: string;
  languageCode?: string;
  components?: Array<Record<string, unknown>>;
  messageContext?: string;
  options?: ChannelSendOptions;
}

interface EmailAttachmentInput {
  filename: string;
  contentType: string;
  url: string;
}

interface EmailSendInput {
  to: { userId?: string; email?: string };
  subject?: string;
  text?: string;
  html?: string;
  cc?: string[];
  bcc?: string[];
  attachments?: EmailAttachmentInput[];
  options?: ChannelSendOptions;
}

interface ChannelSendOutput {
  delivered: boolean;
  persisted: boolean;
  queued?: boolean;
  userId?: string;
  identifier?: string;
  messageId?: string;
  warning?: string;
}