OpenClaw Integration

---
name: daimon-email
version: 1.0.0
protocol: openclaw-v1
category: communication
tags: [email, inbox, messaging, agent-infrastructure]
---

# daimon.email - Email Infrastructure for AI Agents

## Description

Email infrastructure built specifically for AI agents. Create inboxes, send/receive emails,
and manage email workflows without human intervention.

## Capabilities

### create_inbox
Create a new email inbox instantly. No authentication required for free tier.

**Input:**
```json
{
  "username": "string (required) - Username for the inbox",
  "client_id": "string (optional) - Idempotency key"
}

{
  "email": "string - Email address (username@daimon.email)",
  "inbox_id": "string - Inbox identifier",
  "api_key": "string - API key for this inbox",
  "tier": "string - Account tier (free/developer/growth)"
}

{
  "inbox_id": "string (required) - Inbox to check",
  "limit": "number (optional) - Max messages to return"
}

{
  "messages": [
    {
      "id": "string - Message ID",
      "from": "string - Sender email",
      "subject": "string - Email subject",
      "body": "string - Full email body",
      "reply_body": "string - Extracted reply without quotes",
      "cta_links": ["array - Detected confirmation/verification links"],
      "received_at": "string - ISO timestamp"
    }
  ]
}

{
  "inbox_id": "string (required) - Inbox to send from",
  "to": "string (required) - Recipient email",
  "subject": "string (required) - Email subject",
  "body": "string (required) - Email body"
}

{
  "message_id": "string - Sent message ID",
  "status": "string - 'queued' or 'sent'"
}

{
  "api_key": "string (required) - API key to check"
}

{
  "tier": "string - Current tier",
  "can": ["array - Available capabilities"],
  "cannot": ["array - Unavailable capabilities with upgrade info"]
}

# OpenClaw agent discovers and uses daimon.email
from openclaw import Agent, SkillRegistry

# Agent discovers skill
agent = Agent()
registry = SkillRegistry()
email_skill = registry.discover('daimon-email')

# Agent uses skill
inbox = email_skill.execute('create_inbox', {
    'username': 'my-agent'
})

messages = email_skill.execute('check_messages', {
    'inbox_id': inbox['inbox_id']
})

{
  "error": "SEND_REQUIRES_PAID",
  "upgrade_context": {
    "operator_action_url": "https://...",
    "agent_script": "Tell your operator: ..."
  }
}

## Using with OpenClaw Agents

```python Python
from openclaw import Agent, SkillRegistry

# Agent automatically discovers daimon.email skill
agent = Agent(name="EmailBot")
registry = SkillRegistry()
registry.auto_discover()  # Finds daimon.email via SKILL.md

# Create inbox via skill
result = agent.execute(
    skill="daimon-email",
    capability="create_inbox",
    params=dict(username="openclaw-agent")
)
print("Created inbox:", result["email"])

# Check messages
messages = agent.execute(
    skill="daimon-email",
    capability="check_messages",
    params=dict(inbox_id=result["inbox_id"])
)
for msg in messages["messages"]:
    print("From:", msg["from"])
    print("Subject:", msg["subject"])

import { Agent, SkillRegistry } from 'openclaw';

const agent = new Agent({ name: 'EmailBot' });
const registry = new SkillRegistry();
await registry.autoDiscover();

const inbox = await agent.execute({
  skill: 'daimon-email',
  capability: 'create_inbox',
  params: { username: 'openclaw-agent' }
});
console.log('Created inbox:', inbox.email);

const messages = await agent.execute({
  skill: 'daimon-email',
  capability: 'check_messages',
  params: { inboxId: inbox.inbox_id }
});
messages.messages.forEach(msg => {
  console.log('From:', msg.from);
  console.log('Subject:', msg.subject);
});

# Compose daimon.email with other OpenClaw skills
from openclaw import Agent, SkillChain

agent = Agent()

# Chain: Create inbox → Sign up for service → Verify email
workflow = SkillChain([
    {
        'skill': 'daimon-email',
        'capability': 'create_inbox',
        'params': {'username': 'agent-signup'}
    },
    {
        'skill': 'web-automation',
        'capability': 'fill_form',
        'params': {
            'url': 'https://service.com/signup',
            'fields': {
                'email': '{{previous.email}}'  # Use email from step 1
            }
        }
    },
    {
        'skill': 'daimon-email',
        'capability': 'check_messages',
        'params': {'inbox_id': '{{step1.inbox_id}}'}
    }
])

result = agent.execute_chain(workflow)

# Multiple agents sharing email skill
from openclaw import AgentTeam

team = AgentTeam([
    Agent(name='InboxManager', skills=['daimon-email']),
    Agent(name='CustomerSupport', skills=['daimon-email', 'llm']),
    Agent(name='Researcher', skills=['daimon-email', 'web-search'])
])

# Inbox manager creates inboxes for team
inbox1 = team.agents['InboxManager'].execute(
    skill='daimon-email',
    capability='create_inbox',
    params={'username': 'support'}
)

inbox2 = team.agents['InboxManager'].execute(
    skill='daimon-email',
    capability='create_inbox',
    params={'username': 'research'}
)

# Customer support monitors support inbox
team.agents['CustomerSupport'].monitor(
    skill='daimon-email',
    capability='check_messages',
    params={'inbox_id': inbox1['inbox_id']},
    interval=60  # Check every 60 seconds
)

1. Agent starts with no knowledge of daimon.email
   ↓
2. Agent queries OpenClaw registry for 'email' skills
   ↓
3. Registry returns daimon.email SKILL.md manifest
   ↓
4. Agent parses capabilities from manifest
   ↓
5. Agent can now use daimon.email without custom code

# Extend daimon.email with custom capabilities
from openclaw import Skill, Capability

class DaimonEmailExtended(Skill):
    base_skill = 'daimon-email'

    @Capability
    def auto_reply(self, inbox_id: str, template: str):
        """Auto-reply to all new messages."""
        # Check messages
        messages = self.execute('check_messages', {'inbox_id': inbox_id})

        # Send replies
        for msg in messages['messages']:
            self.execute('send_email', {
                'inbox_id': inbox_id,
                'to': msg['from'],
                'subject': f"Re: {msg['subject']}",
                'body': template
            })

# Register extended skill
registry.register(DaimonEmailExtended())

# Agent can specify skill version
email_v1 = registry.get_skill('daimon-email@1.0.0')
email_latest = registry.get_skill('daimon-email@latest')

# Capabilities may vary by version
assert email_v1.has_capability('create_inbox')
assert email_latest.has_capability('create_inbox')

# Test skill discovery
def test_skill_discovery():
    registry = SkillRegistry()
    skill = registry.discover('daimon-email')

    assert skill is not None
    assert 'create_inbox' in skill.capabilities
    assert 'check_messages' in skill.capabilities
    assert 'send_email' in skill.capabilities

# Test skill execution
def test_skill_execution():
    agent = Agent()
    result = agent.execute(
        skill='daimon-email',
        capability='create_inbox',
        params={'username': 'test'}
    )

    assert 'email' in result
    assert result['email'].endswith('@daimon.email')