Email

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('EmailSetup', {
  handler: async (ctx, input) => {
    // Creates support@agentuity.email
    const address = await ctx.email.createAddress('support');
    ctx.logger.info('Address created', { email: address.email, id: address.id });
 
    // List all addresses in the organization
    const addresses = await ctx.email.listAddresses();
 
    // Look up a specific address by ID
    const found = await ctx.email.getAddress(address.id);
 
    // Remove an address when no longer needed
    await ctx.email.deleteAddress(address.id);
 
    return { created: address.email };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('Notifier', {
  handler: async (ctx, input) => {
    const result = await ctx.email.send({ 
      from: 'notifications@agentuity.email', // must be owned by the organization
      to: ['user@example.com'],
      subject: 'Your report is ready',
      text: 'Your weekly report has been generated.',
      html: '<p>Your weekly <strong>report</strong> has been generated.</p>',
    });
 
    ctx.logger.info('Email queued', { id: result.id, status: result.status });
    return { id: result.id };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('ReportMailer', {
  handler: async (ctx, input) => {
    // Read or generate file content, then base64-encode it
    const csvContent = 'date,value\n2026-03-01,42';
    const encoded = Buffer.from(csvContent).toString('base64');
 
    const result = await ctx.email.send({
      from: 'reports@agentuity.email',
      to: ['manager@example.com'],
      subject: 'Monthly Report',
      text: 'Please find the report attached.',
      attachments: [ 
        {
          filename: 'report.csv',
          content: encoded,       // base64-encoded file content
          contentType: 'text/csv', // optional MIME type
        },
      ],
    });
 
    return { id: result.id };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('DeliveryTracker', {
  handler: async (ctx, input) => {
    // Send an email and capture the outbound ID
    const result = await ctx.email.send({
      from: 'notifications@agentuity.email',
      to: ['user@example.com'],
      subject: 'Your report is ready',
      text: 'Your report has been generated.',
    });
 
    // Check delivery status by ID (prefixed with eout_)
    const outbound = await ctx.email.getOutbound(result.id); 
    if (outbound) {
      ctx.logger.info('Delivery status', { status: outbound.status, error: outbound.error });
      // outbound.status: 'pending' | 'success' | 'failed'
    }
 
    // List all outbound emails, or filter by sender address
    const all = await ctx.email.listOutbound();
    const filtered = await ctx.email.listOutbound('eaddr_abc123');
 
    // Delete an outbound record when no longer needed
    await ctx.email.deleteOutbound(result.id);
 
    return { status: outbound?.status };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('InboxReader', {
  handler: async (ctx, input) => {
    // List inbound across all addresses
    const all = await ctx.email.listInbound();
 
    // Or filter by a specific address
    const messages = await ctx.email.listInbound('eaddr_abc123'); 
 
    for (const msg of messages) {
      ctx.logger.info('Inbound message', {
        from: msg.from,
        subject: msg.subject,
        receivedAt: msg.received_at,
      });
    }
 
    // Fetch a single message by its ID (prefixed with einb_)
    const message = await ctx.email.getInbound('einb_abc123');
    if (message) {
      ctx.logger.info('Message body', { text: message.text });
    }
 
    // Delete an inbound message when no longer needed
    await ctx.email.deleteInbound('einb_abc123'); 
 
    return { count: messages.length };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('DestinationSetup', {
  handler: async (ctx, input) => {
    // Forward inbound emails to an HTTP endpoint
    const dest = await ctx.email.createDestination('eaddr_abc123', 'url', {
      url: 'https://example.com/inbound-email',
      headers: { 'X-API-Key': 'secret' },
      method: 'POST',
    });
 
    ctx.logger.info('Destination created', { id: dest.id });
 
    // List all destinations for an address
    const destinations = await ctx.email.listDestinations('eaddr_abc123');
 
    // Remove a destination
    await ctx.email.deleteDestination('eaddr_abc123', dest.id);
 
    return { destinationId: dest.id };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('MailClientSetup', {
  handler: async (ctx, input) => {
    const config = await ctx.email.getConnectionConfig('eaddr_abc123'); 
 
    if (config) {
      ctx.logger.info('IMAP config', {
        host: config.imap.host,
        port: config.imap.port,
        tls: config.imap.tls,
        username: config.imap.username,
      });
    }
 
    return { email: config?.email };
  },
});

import { createAgent } from '@agentuity/runtime';
 
const agent = createAgent('ActivityReporter', {
  handler: async (ctx, input) => {
    // Retrieve the last 30 days of activity
    const result = await ctx.email.getActivity({ days: 30 });
 
    for (const point of result.activity) {
      ctx.logger.info('Daily activity', {
        date: point.date,
        inbound: point.inbound,
        outbound: point.outbound,
      });
    }
 
    return { days: result.days, points: result.activity.length };
  },
});

import { createRouter } from '@agentuity/runtime';
 
const router = createRouter();
 
router.post('/notify', async (c) => {
  const { to, subject, text } = await c.req.json();
 
  const result = await c.var.email.send({ 
    from: 'notifications@agentuity.email',
    to: [to],
    subject,
    text,
  });
 
  return c.json({ id: result.id, status: result.status });
});
 
export default router;