Magic Upgrade Example

import { DaimonClient } from 'daimon-email';
import { WebClient } from '@slack/web-api';

class MagicUpgradeAgent {
  private client: DaimonClient;
  private slackClient: WebClient;
  private inboxId: string;

  constructor(apiKey: string, slackToken: string, inboxId: string) {
    this.client = new DaimonClient({ apiKey });
    this.slackClient = new WebClient(slackToken);
    this.inboxId = inboxId;
  }

  async sendEmail(to: string, subject: string, body: string) {
    try {
      const result = await this.client.inboxes.send(this.inboxId, {
        to,
        subject,
        body
      });

      console.log('✅ Email sent:', result.messageId);
      return result;

    } catch (error: any) {
      if (error.code === 'SEND_REQUIRES_PAID') {
        console.log('⚠️  Sending requires paid tier');
        console.log('💡 Agent suggestion:', error.upgradeContext.agentScript);

        // Request upgrade from operator
        await this.requestUpgrade('Need sending capabilities to continue email automation');

        // Return gracefully - agent knows to wait
        throw new Error('PENDING_UPGRADE: Waiting for operator to upgrade account');
      }

      throw error;
    }
  }

  async requestUpgrade(reason: string) {
    console.log('🔗 Generating magic upgrade link...');

    const upgradeLink = await this.client.account.createUpgradeLink({
      reason,
      returnUrl: `https://my-dashboard.com/agent/${this.inboxId}`,
      metadata: {
        agentId: this.inboxId,
        requestedAt: new Date().toISOString()
      }
    });

    console.log('✅ Magic link created:', upgradeLink.url);

    // Send to operator via Slack
    await this.notifyOperatorSlack(upgradeLink.url, reason);

    return upgradeLink;
  }

  async notifyOperatorSlack(upgradeUrl: string, reason: string) {
    await this.slackClient.chat.postMessage({
      channel: '#agent-notifications',
      blocks: [
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: '⚠️ *Agent Upgrade Required*'
          }
        },
        {
          type: 'section',
          fields: [
            {
              type: 'mrkdwn',
              text: `*Agent:*\n${this.inboxId}`
            },
            {
              type: 'mrkdwn',
              text: `*Reason:*\n${reason}`
            }
          ]
        },
        {
          type: 'actions',
          elements: [
            {
              type: 'button',
              text: {
                type: 'plain_text',
                text: 'Upgrade Account'
              },
              url: upgradeUrl,
              style: 'primary'
            }
          ]
        }
      ]
    });

    console.log('📲 Notification sent to operator via Slack');
  }

  async handleUpgradeWebhook(event: any) {
    if (event.event === 'account.upgraded') {
      console.log('🎉 Account upgraded!');
      console.log('New tier:', event.account.tier);
      console.log('New capabilities:', event.account.capabilities);

      // Notify operator
      await this.slackClient.chat.postMessage({
        channel: '#agent-notifications',
        text: `✅ Agent ${this.inboxId} successfully upgraded to ${event.account.tier} tier!`
      });

      // Resume work
      await this.resumeWork();
    }
  }

  async resumeWork() {
    console.log('🔄 Resuming work after upgrade...');

    // Retry any failed operations
    // This would typically pull from a queue or retry buffer
  }
}

// Usage
const agent = new MagicUpgradeAgent(
  'dm_free_xxx',
  'xoxb-slack-token',
  'inb_abc123'
);

// This will trigger upgrade flow on free tier
await agent.sendEmail(
  'customer@example.com',
  'Welcome!',
  'Thanks for signing up!'
);

// Webhook handler
app.post('/webhook', async (req, res) => {
  await agent.handleUpgradeWebhook(req.body);
  res.status(200).send('OK');
});

from daimon_email import DaimonClient
from slack_sdk import WebClient

class MagicUpgradeAgent:
    def __init__(self, api_key: str, slack_token: str, inbox_id: str):
        self.client = DaimonClient(api_key=api_key)
        self.slack_client = WebClient(token=slack_token)
        self.inbox_id = inbox_id

    def send_email(self, to: str, subject: str, body: str):
        try:
            result = self.client.inboxes.send(self.inbox_id, {
                'to': to,
                'subject': subject,
                'body': body
            })

            print(f'✅ Email sent: {result.message_id}')
            return result

        except Exception as error:
            if hasattr(error, 'code') and error.code == 'SEND_REQUIRES_PAID':
                print('⚠️  Sending requires paid tier')
                print(f'💡 Agent suggestion: {error.upgrade_context["agent_script"]}')

                # Request upgrade from operator
                self.request_upgrade('Need sending capabilities to continue email automation')

                # Return gracefully - agent knows to wait
                raise Exception('PENDING_UPGRADE: Waiting for operator to upgrade account')

            raise error

    def request_upgrade(self, reason: str):
        print('🔗 Generating magic upgrade link...')

        upgrade_link = self.client.account.create_upgrade_link({
            'reason': reason,
            'return_url': f'https://my-dashboard.com/agent/{self.inbox_id}',
            'metadata': {
                'agent_id': self.inbox_id,
                'requested_at': datetime.now().isoformat()
            }
        })

        print(f'✅ Magic link created: {upgrade_link.url}')

        # Send to operator via Slack
        self.notify_operator_slack(upgrade_link.url, reason)

        return upgrade_link

    def notify_operator_slack(self, upgrade_url: str, reason: str):
        self.slack_client.chat_postMessage(
            channel='#agent-notifications',
            blocks=[
                {
                    'type': 'section',
                    'text': {
                        'type': 'mrkdwn',
                        'text': '⚠️ *Agent Upgrade Required*'
                    }
                },
                {
                    'type': 'section',
                    'fields': [
                        {
                            'type': 'mrkdwn',
                            'text': f'*Agent:*\n{self.inbox_id}'
                        },
                        {
                            'type': 'mrkdwn',
                            'text': f'*Reason:*\n{reason}'
                        }
                    ]
                },
                {
                    'type': 'actions',
                    'elements': [
                        {
                            'type': 'button',
                            'text': {
                                'type': 'plain_text',
                                'text': 'Upgrade Account'
                            },
                            'url': upgrade_url,
                            'style': 'primary'
                        }
                    ]
                }
            ]
        )

        print('📲 Notification sent to operator via Slack')

    def handle_upgrade_webhook(self, event: dict):
        if event['event'] == 'account.upgraded':
            print('🎉 Account upgraded!')
            print(f'New tier: {event["account"]["tier"]}')
            print(f'New capabilities: {event["account"]["capabilities"]}')

            # Notify operator
            self.slack_client.chat_postMessage(
                channel='#agent-notifications',
                text=f'✅ Agent {self.inbox_id} successfully upgraded to {event["account"]["tier"]} tier!'
            )

            # Resume work
            self.resume_work()

    def resume_work(self):
        print('🔄 Resuming work after upgrade...')
        # Retry any failed operations

# Usage
agent = MagicUpgradeAgent(
    'dm_free_xxx',
    'xoxb-slack-token',
    'inb_abc123'
)

# This will trigger upgrade flow on free tier
agent.send_email(
    'customer@example.com',
    'Welcome!',
    'Thanks for signing up!'
)