Magic Upgrade Flow

try {
  await client.inboxes.send(inboxId, {
    to: 'customer@example.com',
    subject: 'Your order is ready',
    body: 'Click here to track your shipment...'
  });
} catch (error) {
  if (error.code === 'SEND_REQUIRES_PAID') {
    console.log('Error details:', {
      code: error.code,
      message: error.message,
      upgradeContext: error.upgradeContext
    });
  }
}

try:
    client.inboxes.send(inbox_id, {
        'to': 'customer@example.com',
        'subject': 'Your order is ready',
        'body': 'Click here to track your shipment...'
    })
except DaimonError as e:
    if e.code == 'SEND_REQUIRES_PAID':
        print('Error details:', {
            'code': e.code,
            'message': e.message,
            'upgrade_context': e.upgrade_context
        })

{
  "error": "SEND_REQUIRES_PAID",
  "message": "Sending emails requires a paid tier",
  "upgrade_context": {
    "operator_action_url": "https://daimon.email/upgrade?token=eyJhbGc...",
    "operator_action_label": "Add a payment method to enable sending",
    "agent_script": "Tell your operator: I need sending access to complete the customer notification. Here's a direct upgrade link: https://daimon.email/upgrade?token=eyJhbGc..."
  }
}

class EmailAgent {
  async handleUpgradeNeeded(error) {
    // Option 1: Log for operator monitoring
    console.log(`🚨 OPERATOR ACTION NEEDED: ${error.upgradeContext.agent_script}`);

    // Option 2: Send to operator communication channel
    await this.notifyOperator({
      urgency: 'medium',
      message: error.upgradeContext.agent_script,
      action_url: error.upgradeContext.operator_action_url,
      action_label: error.upgradeContext.operator_action_label
    });

    // Option 3: If agent has UI integration
    await this.ui.showAlert({
      type: 'upgrade_required',
      message: error.upgradeContext.agent_script,
      button: {
        label: error.upgradeContext.operator_action_label,
        url: error.upgradeContext.operator_action_url
      }
    });

    // Wait for upgrade to complete
    await this.waitForUpgrade();
  }
}

class EmailAgent:
    async def handle_upgrade_needed(self, error):
        # Option 1: Log for operator monitoring
        print(f"🚨 OPERATOR ACTION NEEDED: {error.upgrade_context['agent_script']}")

        # Option 2: Send to operator communication channel
        await self.notify_operator({
            'urgency': 'medium',
            'message': error.upgrade_context['agent_script'],
            'action_url': error.upgrade_context['operator_action_url'],
            'action_label': error.upgrade_context['operator_action_label']
        })

        # Option 3: If agent has UI integration
        await self.ui.show_alert({
            'type': 'upgrade_required',
            'message': error.upgrade_context['agent_script'],
            'button': {
                'label': error.upgrade_context['operator_action_label'],
                'url': error.upgrade_context['operator_action_url']
            }
        })

        # Wait for upgrade to complete
        await self.wait_for_upgrade()

// Generate a new magic upgrade link
const link = await client.account.createUpgradeLink({
  target_tier: 'developer',  // or 'growth'
  metadata: {
    agent_id: 'agent-7392',
    task: 'customer-notification',
    urgency: 'high'
  }
});

console.log('Generated upgrade URL:', link.url);
console.log('Expires at:', link.expires_at);

// Share with operator
await sendToSlack(`
  I need to upgrade to continue sending customer notifications.

  Current task blocked: Order confirmation emails
  Required tier: Developer ($9/month)

  → ${link.url}

  This link expires in 7 days.
`);

# Generate a new magic upgrade link
link = client.account.create_upgrade_link({
    'target_tier': 'developer',  # or 'growth'
    'metadata': {
        'agent_id': 'agent-7392',
        'task': 'customer-notification',
        'urgency': 'high'
    }
})

print(f"Generated upgrade URL: {link['url']}")
print(f"Expires at: {link['expires_at']}")

# Share with operator
send_to_slack(f"""
    I need to upgrade to continue sending customer notifications.

    Current task blocked: Order confirmation emails
    Required tier: Developer ($9/month)

    → {link['url']}

    This link expires in 7 days.
""")

// Webhook handler
app.post('/webhook', async (req, res) => {
  const signature = req.headers['x-daimon-signature'];

  if (!verifyWebhookSignature(req.body, signature, WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }

  const { event, data } = req.body;

  if (event === 'account.upgraded') {
    console.log('🎉 Account upgraded!', {
      old_tier: data.old_tier,
      new_tier: data.new_tier,
      upgraded_at: data.upgraded_at,
      expires_at: data.expires_at
    });

    // Resume blocked operations
    await this.resumeBlockedTasks();
  }

  res.status(200).send('OK');
});

// In the agent's task queue
async resumeBlockedTasks() {
  const blocked = await this.getBlockedTasks();

  for (const task of blocked) {
    if (task.blocked_reason === 'SEND_REQUIRES_PAID') {
      // Retry the send operation
      await this.retrySend(task);
    }
  }
}

# Webhook handler
@app.post('/webhook')
async def handle_webhook(request):
    signature = request.headers.get('X-Daimon-Signature')

    if not verify_webhook_signature(request.body, signature, WEBHOOK_SECRET):
        return Response(status=401, text='Invalid signature')

    data = request.json()

    if data['event'] == 'account.upgraded':
        print('🎉 Account upgraded!', {
            'old_tier': data['data']['old_tier'],
            'new_tier': data['data']['new_tier'],
            'upgraded_at': data['data']['upgraded_at'],
            'expires_at': data['data']['expires_at']
        })

        # Resume blocked operations
        await resume_blocked_tasks()

    return Response(status=200, text='OK')

# In the agent's task queue
async def resume_blocked_tasks():
    blocked = await get_blocked_tasks()

    for task in blocked:
        if task['blocked_reason'] == 'SEND_REQUIRES_PAID':
            # Retry the send operation
            await retry_send(task)