backend-sms-messaging

SMS Messaging Skill

Purpose

Build reliable, compliant SMS and messaging systems supporting transactional messages, 2FA delivery, WhatsApp integration, and comprehensive delivery tracking.

Agent Protocol

Trigger

User mentions SMS, text messaging, Twilio, AWS SNS, Vonage, WhatsApp API, 2FA via SMS, OTP delivery, message templates, TCPA compliance, opt-in/out, SMS delivery tracking, or messaging analytics.

Input Context

• SMS provider selection and credentials
• Message types (transactional, 2FA, notifications, alerts)
• Volume estimates and sending quotas
• Compliance requirements (TCPA, GDPR, local regulations)
• WhatsApp Business API requirements (template approval, opt-in)
• Fallback channel requirements
• International sending needs

Output Artifact

SKILL.md adherence document plus implemented messaging service, provider integration, template management, delivery tracking, and compliance handling.

Response Format

No preamble. No postamble. No explanations. No filler/hedging/transitions. Compress output — why use many token when few do trick.

Completion Criteria

• SMS provider integrated with failover/secondary provider
• Message template system with variable injection implemented
• 2FA OTP generation, delivery, verification flow operational
• Rate limiting per recipient, per number, per campaign enforced
• Opt-in/opt-out mechanism with consent record storage
• Delivery status tracking (sent, delivered, failed, undelivered)
• WhatsApp Business API integration with approved templates
• Cost tracking and budget alerts configured
• Fallback channel (SMS -> Voice -> Email) implemented
• Compliance documentation (TCPA, GDPR) generated

Max Response Length

4096 tokens

Workflow

1. Provider Abstraction: Unified interface over multiple providers with failover.

interface MessageProvider {
  name: string;
  send(params: SendParams): Promise<SendResult>;
  getStatus(messageId: string): Promise<DeliveryStatus>;
  getBalance(): Promise<number>;
}

class MessagingService {
  private providers: MessageProvider[];

  constructor(primary: MessageProvider, secondary: MessageProvider) {
    this.providers = [primary, secondary];
  }

  async send(params: SendParams): Promise<SendResult> {
    const errors: Error[] = [];

    for (const provider of this.providers) {
      try {
        const result = await provider.send(params);
        await this.recordMessage({ ...params, provider: provider.name, messageId: result.messageId });
        return result;
      } catch (error) {
        errors.push(error);
        await this.recordFailover(params, provider.name, error.message);
      }
    }

    throw new AggregateError(errors, 'All message providers failed');
  }

  private async recordMessage(data: MessageRecord): Promise<void> {
    await MessageLog.create({
      to: data.to,
      from: data.from,
      body: data.body,
      provider: data.provider,
      messageId: data.messageId,
      status: 'sent',
      sentAt: new Date(),
      type: data.type,
    });
  }
}