@clawpump/claw-agent 0.1.6 → 0.1.8

package/agent/hermes_cli/web_server.py

@@ -12081,46 +12081,105 @@ def _parse_mcp_json(text: str) -> Any:
     return data
 
 
+# ── Warm ClawPump MCP session (shared by the dashboard's MCP routes) ──────
+# Keep ONE MCP session alive and reuse it — the same thing the agent runtime
+# does, which is why chat kept working while the dashboard didn't. Opening a
+# fresh connection per request stalls the shared MCP event loop under OAuth
+# token churn and wedges every page until a restart. One warm session plus a
+# single reconnect-on-failure stays fast and self-heals. The lock serializes
+# calls (one JSON-RPC stream per session); the short timeout means a stall
+# fails fast instead of hanging forever.
+_warm_mcp_lock = threading.Lock()
+_warm_mcp_server: Any = None  # live MCPServerTask, kept warm by its keepalive ping
+
+
+class _McpToolError(RuntimeError):
+    """The tool ran but returned an error — the session itself is healthy."""
+
+
+def _clawpump_call(tool: str, arguments: Optional[dict] = None, *, timeout: float = 20) -> Any:
+    """Call a ClawPump MCP tool over the dashboard's warm, reused session.
+
+    Reuses one long-lived connection and reconnects only if the session has
+    died, so the dashboard behaves like the agent's persistent connection
+    instead of reconnecting (and stalling) per request. Returns parsed JSON;
+    raises ``RuntimeError`` when the MCP is unconfigured or the tool errors.
+    """
+    global _warm_mcp_server
+
+    name, cfg = _clawpump_mcp()
+    if not name:
+        raise RuntimeError("ClawPump MCP is not configured. Run `hermes clawpump setup`.")
+
+    from tools.mcp_tool import _ensure_mcp_loop, _run_on_mcp_loop, _connect_server
+    from hermes_cli.mcp_config import _resolve_mcp_server_config
+
+    cfg = _resolve_mcp_server_config(cfg)
+    _ensure_mcp_loop()
+
+    def _invoke(server: Any) -> Any:
+        async def _coro():
+            result = await server.session.call_tool(tool, arguments=arguments or {})
+            text = "".join(b.text for b in (result.content or []) if hasattr(b, "text"))
+            if getattr(result, "isError", False):
+                raise _McpToolError(text or "MCP tool returned an error")
+            return text
+
+        data = _parse_mcp_json(_run_on_mcp_loop(_coro, timeout=timeout))
+        if isinstance(data, dict) and isinstance(data.get("error"), str) and data["error"]:
+            raise _McpToolError(data["error"])
+        return data
+
+    with _warm_mcp_lock:
+        server = _warm_mcp_server
+        if server is not None:
+            try:
+                return _invoke(server)
+            except _McpToolError:
+                raise  # the session is fine — the tool itself returned an error
+            except Exception:
+                _warm_mcp_server = None  # transport died — drop it and reconnect
+                try:
+                    _run_on_mcp_loop(lambda: server.shutdown(), timeout=5)
+                except Exception:
+                    pass
+        server = _run_on_mcp_loop(lambda: _connect_server(name, cfg), timeout=timeout)
+        _warm_mcp_server = server
+        return _invoke(server)
+
+
 @app.get("/api/wallet/balances")
 def get_wallet_balances():
     """Agent wallet balances (name + address + SOL + USDC) via the ClawPump MCP.
 
     Calls ``get_wallet_summaries`` (and ``list_agents`` for display names) over
-    a short-lived MCP session (OAuth/API-key from ``hermes clawpump setup``).
-    Read-only. Sync def so FastAPI runs it in a threadpool — MCP call blocks.
+    the dashboard's warm MCP session. Read-only. Sync def — MCP call blocks.
     """
-    from hermes_cli.mcp_config import _call_single_tool
-
-    srv_name, srv_cfg = _clawpump_mcp()
-    if not srv_name:
-        return {
-            "ok": False,
-            "error": "ClawPump MCP is not configured. Run `hermes clawpump setup`.",
-            "wallets": [],
-        }
-
     try:
-        text = _call_single_tool(srv_name, srv_cfg, "get_wallet_summaries", {})
+        data = _clawpump_call("get_wallet_summaries", {})
     except Exception as exc:  # surface any connection / tool error to the UI
         return {"ok": False, "error": str(exc), "wallets": []}
 
-    data = _parse_mcp_json(text)
     wallets = data if isinstance(data, list) else []
 
     # Enrich with the agent's display name — the summaries only carry the
     # agent_id UUID. Best-effort: a failure here just leaves ``name`` unset.
     try:
-        agents = _parse_mcp_json(_call_single_tool(srv_name, srv_cfg, "list_agents", {}))
+        agents = _clawpump_call("list_agents", {})
         if isinstance(agents, dict):
             agents = agents.get("agents")
-        names = {
-            a["id"]: a.get("name")
+        by_id = {
+            a["id"]: a
             for a in (agents or [])
             if isinstance(a, dict) and a.get("id")
         }
         for w in wallets:
             if isinstance(w, dict):
-                w["name"] = names.get(w.get("agent_id"))
+                meta = by_id.get(w.get("agent_id")) or {}
+                w["name"] = meta.get("name")
+                w["token_mint"] = meta.get("token_mint")
+                # avatar_url is fetched lazily via /api/agent/avatar — list_agents
+                # nulls it; only the single get_agent returns it.
     except Exception:
         pass
 
@@ -12188,42 +12247,178 @@ def post_wallet_transfer(body: WalletTransferBody):
 
 
 @app.get("/api/x402/search")
-def x402_search(q: str = ""):
+def x402_search(q: str = "", network: str = "solana"):
     """Search the x402 marketplace via the ClawPump MCP (``dexter_search``).
 
-    Free/read-only discovery: returns paid x402 resources (URL, price, schema)
-    the agent could pay from its own ClawPump wallet. Sync def — MCP blocks.
+    Discovery (Dexter + PayAI aggregation) and ``network`` filtering live in the
+    MCP tool — the dashboard just forwards ``query`` + ``network`` and renders.
+    The ClawPump wallet settles x402 in USDC on Solana, so the default is
+    ``solana``; pass ``network=all`` to see every chain. Sync def — MCP blocks.
     """
-    from hermes_cli.mcp_config import _call_single_tool
-
     query = (q or "").strip()
     if not query:
-        return {"ok": True, "query": "", "results": []}
-
-    srv_name, srv_cfg = _clawpump_mcp()
-    if not srv_name:
-        return {
-            "ok": False,
-            "error": "ClawPump MCP is not configured. Run `hermes clawpump setup`.",
-            "results": [],
-        }
+        return {"ok": True, "query": "", "network": network, "results": []}
 
     try:
-        text = _call_single_tool(srv_name, srv_cfg, "dexter_search", {"query": query})
+        data = _clawpump_call("dexter_search", {"query": query, "network": network})
     except Exception as exc:  # surface any connection / tool error to the UI
         return {"ok": False, "error": str(exc), "results": []}
 
-    data = _parse_mcp_json(text)
     if isinstance(data, dict):
-        if isinstance(data.get("error"), str) and data["error"]:
-            return {"ok": False, "error": data["error"], "results": []}
         results = data.get("results")
         results = results if isinstance(results, list) else []
     elif isinstance(data, list):
         results = data
     else:
         results = []
-    return {"ok": True, "query": query, "results": results}
+    return {"ok": True, "query": query, "network": network, "results": results}
+
+
+# ---------------------------------------------------------------------------
+# Agent Mail (AgentMail) — agent email inbox via the ClawPump MCP
+# ---------------------------------------------------------------------------
+# Thin proxies over the ``agent_mail_*`` MCP tools, mirroring the x402 route
+# above. The two spending/outward actions (provision an inbox, send an email)
+# require an explicit ``confirm`` from the UI — the dashboard never auto-spends.
+
+
+def _agent_args(agent_id: Optional[str]) -> Dict[str, Any]:
+    """Base args for a ClawPump MCP call. Omit ``agent_id`` entirely when the
+    dashboard hasn't picked one so the MCP resolves the default/only agent."""
+    aid = (agent_id or "").strip()
+    return {"agent_id": aid} if aid else {}
+
+
+def _clawpump_call_once(tool: str, arguments: Optional[dict] = None, *, timeout: float = 30) -> Any:
+    """Call a ClawPump MCP tool over a fresh, one-shot connection.
+
+    For rare, irreversible actions (wallet transfers, email sends, paid inbox
+    provisioning): a fresh connect means current auth and — crucially — exactly
+    one attempt, so a dropped response is never silently re-sent. Frequent reads
+    use the warm ``_clawpump_call`` instead.
+    """
+    from hermes_cli.mcp_config import _call_single_tool
+
+    name, cfg = _clawpump_mcp()
+    if not name:
+        raise RuntimeError("ClawPump MCP is not configured. Run `hermes clawpump setup`.")
+    data = _parse_mcp_json(_call_single_tool(name, cfg, tool, arguments or {}, connect_timeout=timeout))
+    if isinstance(data, dict) and isinstance(data.get("error"), str) and data["error"]:
+        raise RuntimeError(data["error"])
+    return data
+
+
+class MailCreateBody(BaseModel):
+    agent_id: Optional[str] = None
+    username: Optional[str] = None
+    confirm: bool = False
+
+
+class MailSendBody(BaseModel):
+    agent_id: Optional[str] = None
+    to: Any = None  # str | list[str] — the MCP tool accepts either
+    subject: str
+    text: Optional[str] = None
+    html: Optional[str] = None
+    cc: Optional[List[str]] = None
+    bcc: Optional[List[str]] = None
+    reply_to: Optional[str] = None
+    confirm: bool = False
+
+
+@app.get("/api/mail/address")
+def mail_address(agent_id: str = ""):
+    """The agent's email address + inbox status via ``agent_mail_get_address``."""
+    try:
+        data = _clawpump_call("agent_mail_get_address", _agent_args(agent_id))
+    except Exception as exc:
+        return {"ok": False, "error": str(exc), "has_inbox": False, "inbox": None}
+    inbox = data.get("inbox") if isinstance(data, dict) else None
+    return {"ok": True, "has_inbox": bool(inbox), "inbox": inbox}
+
+
+@app.get("/api/mail/messages")
+def mail_messages(agent_id: str = "", direction: str = "", limit: int = 50):
+    """List the agent's emails (synced inbound + sent) via ``agent_mail_list``."""
+    args = _agent_args(agent_id)
+    if direction in ("inbound", "outbound"):
+        args["direction"] = direction
+    args["limit"] = max(1, min(int(limit or 50), 200))
+    try:
+        data = _clawpump_call("agent_mail_list", args)
+    except Exception as exc:
+        return {"ok": False, "error": str(exc), "messages": []}
+    messages = data.get("messages") if isinstance(data, dict) else None
+    return {"ok": True, "messages": messages if isinstance(messages, list) else []}
+
+
+@app.get("/api/mail/message")
+def mail_message(message_id: str, agent_id: str = ""):
+    """Read one email (full body) via ``agent_mail_read``."""
+    args = _agent_args(agent_id)
+    args["message_id"] = message_id
+    try:
+        data = _clawpump_call("agent_mail_read", args)
+    except Exception as exc:
+        return {"ok": False, "error": str(exc), "message": None}
+    message = data.get("message") if isinstance(data, dict) else None
+    return {"ok": True, "message": message}
+
+
+@app.post("/api/mail/create")
+def mail_create(body: MailCreateBody):
+    """Provision the agent's inbox (~$2 USDC) via ``agent_mail_create``."""
+    if not body.confirm:
+        return {
+            "ok": False,
+            "error": "Provisioning an inbox costs ~$2 USDC from the agent wallet — confirm to proceed.",
+        }
+    args = _agent_args(body.agent_id)
+    args["confirm_provision"] = True
+    if body.username and body.username.strip():
+        args["username"] = body.username.strip()
+    try:
+        data = _clawpump_call_once("agent_mail_create", args)
+    except Exception as exc:
+        return {"ok": False, "error": str(exc)}
+    if not isinstance(data, dict):
+        data = {}
+    return {
+        "ok": True,
+        "inbox": data.get("inbox"),
+        "alreadyExisted": bool(data.get("alreadyExisted")),
+        "note": data.get("note"),
+    }
+
+
+@app.post("/api/mail/send")
+def mail_send(body: MailSendBody):
+    """Send an email from the agent's inbox via ``agent_mail_send`` (x402)."""
+    if not body.confirm:
+        return {"ok": False, "error": "Sending email is outward-facing — confirm to proceed."}
+    if not (body.text and body.text.strip()) and not (body.html and body.html.strip()):
+        return {"ok": False, "error": "Provide a message body."}
+    if not body.to:
+        return {"ok": False, "error": "At least one recipient is required."}
+    args = _agent_args(body.agent_id)
+    args["confirm_send"] = True
+    args["to"] = body.to
+    args["subject"] = body.subject
+    if body.text:
+        args["text"] = body.text
+    if body.html:
+        args["html"] = body.html
+    if body.cc:
+        args["cc"] = body.cc
+    if body.bcc:
+        args["bcc"] = body.bcc
+    if body.reply_to and body.reply_to.strip():
+        args["reply_to"] = body.reply_to.strip()
+    try:
+        data = _clawpump_call_once("agent_mail_send", args)
+    except Exception as exc:
+        return {"ok": False, "error": str(exc)}
+    return {"ok": True, "result": data}
 
 
 _FONT_DEFAULT_ID = "space-grotesk"

package/agent/skills/clawpump/SKILL.md

@@ -144,6 +144,7 @@ Common patterns:
 - **Paid x402 API call (agent wallet pays):** `pay_sh_search` → `pay_sh_provider_details` (price) → `pay_sh_prepare_call` → (confirm price with user) → `pay_sh_execute_approved`. The agent needs the `x402` skill (`update_agent` with `enabled_skills`).
 - **Discover x402 APIs on Dexter:** `dexter_search` (free, by capability — e.g. "ETH price", "image generation") returns matching resources with their payable `resourceUrl`, HTTP method, per-call USDC price, and input schema. No separate Dexter wallet.
 - **Pay ANY x402 URL (open, not just a catalog):** `x402_pay_check` (free — fetch the URL's 402 challenge → price + input schema) → quote the price to the user → `x402_pay` (pays from the agent's ClawPump wallet, `confirm_payment: true`, `max_amount_usd` = the cap the user approved). Works on any x402 endpoint, including a `resourceUrl` from `dexter_search`. The wallet signs server-side; spend is hard-capped. Needs the `x402` skill (`update_agent` with `enabled_skills`).
+- **Payment funds:** check with `get_wallet_summaries` (`usdc_balance`).
 - **Pay your Hermes inference from the ClawPump wallet (UsePod):** if the user runs Hermes on their own UsePod pod (`USEPOD_API_KEY` in `~/.hermes/.env`), they can top that pod up straight from their ClawPump wallet instead of funding it manually at usepod.ai. Flow: `get_balance` (confirm the agent wallet holds enough USDC) → ask for the amount + their 16-hex `deposit_code` (from UsePod `/v1/register`) → quote both back → (confirm) `usepod_deposit` with `confirm_deposit: true`. The full amount goes on-chain into that pod (no fee); UsePod then draws inference cost from it. This is **separate** from ClawPump's own hosted chat/credits — it just pays the user's own pod from their wallet.
 
 ## Setting up Pod (UsePod) — auto flow

package/agent/web/src/App.tsx

@@ -33,6 +33,7 @@ import {
   Globe,
   Heart,
   KeyRound,
+  Mail,
   Menu,
   MessageSquare,
   Package,
@@ -76,6 +77,7 @@ import type { SystemAction } from "@/contexts/system-actions-context";
 import ConfigPage from "@/pages/ConfigPage";
 import WalletPage from "@/pages/WalletPage";
 import X402Page from "@/pages/X402Page";
+import AgentMailPage from "@/pages/AgentMailPage";
 import DocsPage from "@/pages/DocsPage";
 import EnvPage from "@/pages/EnvPage";
 import FilesPage from "@/pages/FilesPage";
@@ -137,6 +139,7 @@ const BUILTIN_ROUTES_CORE: Record<string, ComponentType> = {
   "/": RootRedirect,
   "/wallet": WalletPage,
   "/x402": X402Page,
+  "/mail": AgentMailPage,
   "/sessions": SessionsPage,
   "/files": FilesPage,
   "/analytics": AnalyticsPage,
@@ -168,6 +171,7 @@ function ChatRouteSink() {
 const BUILTIN_NAV_REST: NavItem[] = [
   { path: "/wallet", label: "Wallet", icon: Wallet },
   { path: "/x402", label: "x402", icon: Zap },
+  { path: "/mail", label: "Mail", icon: Mail },
   {
     path: "/sessions",
     labelKey: "sessions",
@@ -522,10 +526,9 @@ export default function App() {
         </Button>
 
         <img
-          src="/claw-logo.webp"
+          src="/claw-logo.png"
           alt=""
           className="h-7 w-7 shrink-0"
-          style={{ mixBlendMode: "screen" }}
         />
         <Typography
           className="font-bold text-[0.95rem] leading-[0.95] tracking-[0.05em] text-midground"
@@ -587,10 +590,9 @@ export default function App() {
                 <PluginSlot name="header-left" />
 
                 <img
-                  src="/claw-logo.webp"
+                  src="/claw-logo.png"
                   alt="Claw Agent"
                   className="h-8 w-8 shrink-0"
-                  style={{ mixBlendMode: "screen" }}
                 />
                 <Typography
                   className="font-bold text-[1.125rem] leading-[0.95] tracking-[0.0525rem] text-midground uppercase"

package/agent/web/src/lib/api.ts

@@ -313,6 +313,8 @@ function appendProfileParam(url: string, profile?: string): string {
 export interface AgentWalletBalance {
   agent_id: string;
   name?: string | null;
+  avatar_url?: string | null;
+  token_mint?: string | null;
   wallet_address: string | null;
   sol_balance: number | null;
   usdc_balance: number | null;
@@ -369,6 +371,86 @@ export interface X402SearchResponse {
   results: X402Result[];
 }
 
+// ── Agent Mail (AgentMail, via the ClawPump MCP) ───────────────────────
+export interface MailInbox {
+  id: string;
+  agentId: string;
+  provider: string;
+  inboxId: string;
+  emailAddress: string;
+  username: string;
+  domain: string;
+  webhookId: string | null;
+  verified: boolean;
+  status: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface MailMessage {
+  id: string;
+  agentId: string;
+  inboxId: string;
+  messageId: string;
+  threadId: string | null;
+  direction: "inbound" | "outbound";
+  fromAddress: string | null;
+  toAddresses: string[];
+  ccAddresses: string[];
+  subject: string | null;
+  textBody: string | null;
+  htmlBody: string | null;
+  preview: string | null;
+  read: boolean;
+  agentmailCreatedAt: string | null;
+  createdAt: string;
+}
+
+export interface MailAddressResponse {
+  ok: boolean;
+  error?: string;
+  has_inbox: boolean;
+  inbox: MailInbox | null;
+}
+
+export interface MailMessagesResponse {
+  ok: boolean;
+  error?: string;
+  messages: MailMessage[];
+}
+
+export interface MailMessageResponse {
+  ok: boolean;
+  error?: string;
+  message: MailMessage | null;
+}
+
+export interface MailCreateResponse {
+  ok: boolean;
+  error?: string;
+  inbox?: MailInbox | null;
+  alreadyExisted?: boolean;
+  note?: string | null;
+}
+
+export interface MailSendBody {
+  agent_id: string;
+  to: string[];
+  subject: string;
+  text?: string;
+  html?: string;
+  cc?: string[];
+  bcc?: string[];
+  reply_to?: string;
+  confirm: boolean;
+}
+
+export interface MailSendResponse {
+  ok: boolean;
+  error?: string;
+  result?: unknown;
+}
+
 export const api = {
   getStatus: () => fetchJSON<StatusResponse>("/api/status"),
   getWalletBalances: () =>
@@ -381,6 +463,36 @@ export const api = {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body),
     }),
+
+  // ── Agent Mail (AgentMail) ─────────────────────────────────────────
+  // Every call carries an explicit agent_id — the MCP requires it once the
+  // account has more than one agent.
+  getMailAddress: (agentId: string) =>
+    fetchJSON<MailAddressResponse>(
+      `/api/mail/address?agent_id=${encodeURIComponent(agentId)}`,
+    ),
+  listMail: (opts: { agentId: string; direction?: "inbound" | "outbound"; limit?: number }) => {
+    const qs = new URLSearchParams({ agent_id: opts.agentId });
+    if (opts.direction) qs.set("direction", opts.direction);
+    if (opts.limit) qs.set("limit", String(opts.limit));
+    return fetchJSON<MailMessagesResponse>(`/api/mail/messages?${qs.toString()}`);
+  },
+  readMail: (messageId: string, agentId: string) =>
+    fetchJSON<MailMessageResponse>(
+      `/api/mail/message?message_id=${encodeURIComponent(messageId)}&agent_id=${encodeURIComponent(agentId)}`,
+    ),
+  createInbox: (body: { agent_id: string; username?: string; confirm: boolean }) =>
+    fetchJSON<MailCreateResponse>("/api/mail/create", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }),
+  sendMail: (body: MailSendBody) =>
+    fetchJSON<MailSendResponse>("/api/mail/send", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }),
   /**
    * Identity probe for the dashboard auth gate (Phase 7).
    *

package/agent/web/src/pages/AgentMailPage.tsx

@@ -0,0 +1,684 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+  ArrowLeft,
+  Check,
+  Copy,
+  Inbox,
+  Mail,
+  PenSquare,
+  RefreshCw,
+  Send,
+  ShieldCheck,
+} from "lucide-react";
+import { api } from "@/lib/api";
+import type { AgentWalletBalance, MailInbox, MailMessage } from "@/lib/api";
+import { Button } from "@nous-research/ui/ui/components/button";
+import { Badge } from "@nous-research/ui/ui/components/badge";
+import { Spinner } from "@nous-research/ui/ui/components/spinner";
+import {
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+} from "@nous-research/ui/ui/components/card";
+
+type View = "list" | "read" | "compose";
+type Filter = "all" | "inbound" | "outbound";
+
+const EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+
+function parseRecipients(raw: string): string[] {
+  return raw
+    .split(/[\s,;]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function formatDate(iso: string | null): string {
+  if (!iso) return "";
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return "";
+  return d.toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+const inputCls =
+  "w-full rounded-md border border-border bg-background px-3 py-2 text-sm outline-none focus:border-primary";
+
+function CopyButton({ value }: { value: string }) {
+  const [copied, setCopied] = useState(false);
+  const onCopy = useCallback(() => {
+    navigator.clipboard
+      .writeText(value)
+      .then(() => {
+        setCopied(true);
+        setTimeout(() => setCopied(false), 1500);
+      })
+      .catch(() => {});
+  }, [value]);
+  return (
+    <button
+      type="button"
+      onClick={onCopy}
+      title="Copy email address"
+      aria-label="Copy email address"
+      className="inline-flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+    >
+      {copied ? <Check className="h-4 w-4 text-green-500" /> : <Copy className="h-4 w-4" />}
+    </button>
+  );
+}
+
+export default function AgentMailPage() {
+  // ── Agent selection (the MCP requires an explicit agent_id) ────────
+  const [agents, setAgents] = useState<AgentWalletBalance[]>([]);
+  const [agentId, setAgentId] = useState("");
+
+  // ── Inbox state ────────────────────────────────────────────────────
+  const [inbox, setInbox] = useState<MailInbox | null>(null);
+  const [hasInbox, setHasInbox] = useState(false);
+  const [inboxLoading, setInboxLoading] = useState(true);
+  const [inboxError, setInboxError] = useState<string | null>(null);
+
+  // ── Provisioning ───────────────────────────────────────────────────
+  const [username, setUsername] = useState("");
+  const [creating, setCreating] = useState(false);
+  const [createArmed, setCreateArmed] = useState(false);
+  const [createError, setCreateError] = useState<string | null>(null);
+
+  // ── Messages ───────────────────────────────────────────────────────
+  const [view, setView] = useState<View>("list");
+  const [filter, setFilter] = useState<Filter>("all");
+  const [messages, setMessages] = useState<MailMessage[]>([]);
+  const [messagesLoading, setMessagesLoading] = useState(false);
+  const [messagesError, setMessagesError] = useState<string | null>(null);
+  const [selected, setSelected] = useState<MailMessage | null>(null);
+  const [selectedLoading, setSelectedLoading] = useState(false);
+
+  // ── Compose ────────────────────────────────────────────────────────
+  const [to, setTo] = useState("");
+  const [cc, setCc] = useState("");
+  const [bcc, setBcc] = useState("");
+  const [subject, setSubject] = useState("");
+  const [bodyText, setBodyText] = useState("");
+  const [replyTo, setReplyTo] = useState("");
+  const [sending, setSending] = useState(false);
+  const [sendArmed, setSendArmed] = useState(false);
+  const [sendError, setSendError] = useState<string | null>(null);
+
+  const loadInbox = useCallback(() => {
+    if (!agentId) return;
+    setInboxLoading(true);
+    setInboxError(null);
+    api
+      .getMailAddress(agentId)
+      .then((resp) => {
+        if (resp.ok) {
+          setInbox(resp.inbox);
+          setHasInbox(resp.has_inbox);
+        } else {
+          setInbox(null);
+          setHasInbox(false);
+          setInboxError(resp.error ?? "Could not load inbox");
+        }
+      })
+      .catch((e) => setInboxError(e instanceof Error ? e.message : String(e)))
+      .finally(() => setInboxLoading(false));
+  }, [agentId]);
+
+  const loadMessages = useCallback(() => {
+    if (!agentId) return;
+    setMessagesLoading(true);
+    setMessagesError(null);
+    api
+      .listMail({ agentId, direction: filter === "all" ? undefined : filter, limit: 100 })
+      .then((resp) => {
+        if (resp.ok) {
+          setMessages(resp.messages ?? []);
+        } else {
+          setMessagesError(resp.error ?? "Could not load messages");
+          setMessages([]);
+        }
+      })
+      .catch((e) => setMessagesError(e instanceof Error ? e.message : String(e)))
+      .finally(() => setMessagesLoading(false));
+  }, [agentId, filter]);
+
+  // Load the agent list once; default to the first agent.
+  useEffect(() => {
+    api
+      .getWalletBalances()
+      .then((r) => {
+        if (r.ok && r.wallets.length) {
+          setAgents(r.wallets);
+          setAgentId((cur) => cur || r.wallets[0].agent_id);
+        }
+      })
+      .catch(() => {});
+  }, []);
+
+  useEffect(() => {
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    loadInbox();
+  }, [loadInbox]);
+
+  useEffect(() => {
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    if (hasInbox) loadMessages();
+  }, [hasInbox, loadMessages]);
+
+  const createInbox = useCallback(() => {
+    setCreating(true);
+    setCreateError(null);
+    api
+      .createInbox({ agent_id: agentId, username: username.trim() || undefined, confirm: true })
+      .then((resp) => {
+        if (resp.ok) {
+          setCreateArmed(false);
+          if (resp.inbox) {
+            setInbox(resp.inbox);
+            setHasInbox(true);
+          } else {
+            loadInbox();
+          }
+        } else {
+          setCreateError(resp.error ?? "Could not create inbox");
+        }
+      })
+      .catch((e) => setCreateError(e instanceof Error ? e.message : String(e)))
+      .finally(() => setCreating(false));
+  }, [agentId, username, loadInbox]);
+
+  const openMessage = useCallback(
+    (m: MailMessage) => {
+      setSelected(m);
+      setView("read");
+      setSelectedLoading(true);
+      api
+        .readMail(m.messageId, agentId)
+        .then((resp) => {
+          if (resp.ok && resp.message) setSelected(resp.message);
+        })
+        .catch(() => {})
+        .finally(() => setSelectedLoading(false));
+    },
+    [agentId],
+  );
+
+  const recipients = useMemo(() => parseRecipients(to), [to]);
+  const selectedWallet = useMemo(
+    () => agents.find((a) => a.agent_id === agentId) ?? null,
+    [agents, agentId],
+  );
+
+  const startCompose = useCallback(() => {
+    setSendError(null);
+    setSendArmed(false);
+    setView("compose");
+  }, []);
+
+  const sendMail = useCallback(() => {
+    const toList = parseRecipients(to);
+    const ccList = parseRecipients(cc);
+    const bccList = parseRecipients(bcc);
+    const bad = [...toList, ...ccList, ...bccList].find((a) => !EMAIL_RE.test(a));
+    if (toList.length === 0) {
+      setSendError("Add at least one recipient.");
+      setSendArmed(false);
+      return;
+    }
+    if (bad) {
+      setSendError(`Not a valid email: ${bad}`);
+      setSendArmed(false);
+      return;
+    }
+    if (!subject.trim()) {
+      setSendError("Add a subject.");
+      setSendArmed(false);
+      return;
+    }
+    if (!bodyText.trim()) {
+      setSendError("Write a message.");
+      setSendArmed(false);
+      return;
+    }
+    setSending(true);
+    setSendError(null);
+    api
+      .sendMail({
+        agent_id: agentId,
+        to: toList,
+        cc: ccList.length ? ccList : undefined,
+        bcc: bccList.length ? bccList : undefined,
+        subject: subject.trim(),
+        text: bodyText,
+        reply_to: replyTo.trim() || undefined,
+        confirm: true,
+      })
+      .then((resp) => {
+        if (resp.ok) {
+          setTo("");
+          setCc("");
+          setBcc("");
+          setSubject("");
+          setBodyText("");
+          setReplyTo("");
+          setSendArmed(false);
+          setView("list");
+          loadMessages();
+        } else {
+          setSendError(resp.error ?? "Send failed");
+          setSendArmed(false);
+        }
+      })
+      .catch((e) => {
+        setSendError(e instanceof Error ? e.message : String(e));
+        setSendArmed(false);
+      })
+      .finally(() => setSending(false));
+  }, [agentId, to, cc, bcc, subject, bodyText, replyTo, loadMessages]);
+
+  // ── Render ─────────────────────────────────────────────────────────
+  return (
+    <div className="mx-auto max-w-3xl space-y-4 p-4">
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <div className="flex items-center gap-2">
+          <Mail className="h-5 w-5 text-muted-foreground" />
+          <h1 className="text-lg font-semibold">Agent Mail</h1>
+          {agents.length > 0 && (
+            <select
+              value={agentId}
+              onChange={(e) => {
+                setAgentId(e.target.value);
+                setView("list");
+                setSelected(null);
+              }}
+              title="Select agent"
+              className="ml-1 max-w-[180px] rounded-md border border-border bg-background px-2 py-1 text-sm outline-none focus:border-primary"
+            >
+              {agents.map((a) => (
+                <option key={a.agent_id} value={a.agent_id}>
+                  {a.name || a.agent_id.slice(0, 8)}
+                </option>
+              ))}
+            </select>
+          )}
+        </div>
+        {hasInbox && view === "list" && (
+          <div className="flex items-center gap-2">
+            <button
+              type="button"
+              onClick={loadMessages}
+              title="Refresh"
+              aria-label="Refresh"
+              className="inline-flex h-8 w-8 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+            >
+              <RefreshCw className={`h-4 w-4 ${messagesLoading ? "animate-spin" : ""}`} />
+            </button>
+            <Button size="sm" prefix={<PenSquare className="h-4 w-4" />} onClick={startCompose}>
+              Compose
+            </Button>
+          </div>
+        )}
+      </div>
+
+      {/* Inbox address bar */}
+      {hasInbox && inbox && (
+        <Card>
+          <CardContent className="flex flex-wrap items-center justify-between gap-2 py-3">
+            <div className="flex min-w-0 items-center gap-2">
+              <Inbox className="h-4 w-4 shrink-0 text-muted-foreground" />
+              <span className="truncate font-mono text-sm text-emerald-300">
+                {inbox.emailAddress}
+              </span>
+              <CopyButton value={inbox.emailAddress} />
+            </div>
+            <div className="flex items-center gap-1.5">
+              {inbox.verified && (
+                <Badge tone="success" className="shrink-0">
+                  <ShieldCheck className="mr-1 h-3 w-3" /> verified
+                </Badge>
+              )}
+              {inbox.status && inbox.status !== "active" && (
+                <Badge tone="secondary">{inbox.status}</Badge>
+              )}
+            </div>
+          </CardContent>
+        </Card>
+      )}
+
+      {inboxError && (
+        <Card className="border-destructive/40">
+          <CardContent className="py-3 text-sm text-destructive">{inboxError}</CardContent>
+        </Card>
+      )}
+
+      {inboxLoading ? (
+        <div className="flex justify-center py-12">
+          <Spinner />
+        </div>
+      ) : !hasInbox ? (
+        /* ── Provision an inbox ─────────────────────────────────────── */
+        <Card>
+          <CardHeader className="pb-2">
+            <CardTitle className="text-sm font-semibold">No inbox yet</CardTitle>
+          </CardHeader>
+          <CardContent className="space-y-3">
+            <p className="text-sm text-muted-foreground">
+              Give this agent a real email address (e.g.{" "}
+              <span className="font-mono text-foreground">name@agentmail.to</span>) so it can
+              send and receive mail. Provisioning is a one-time{" "}
+              <span className="font-semibold text-foreground">~$2 USDC</span> payment from the
+              agent&apos;s own wallet over x402.
+            </p>
+            {selectedWallet && (
+              <div className="flex items-center justify-between rounded-md border border-border bg-background px-3 py-2">
+                <span className="text-sm text-muted-foreground">This agent&apos;s USDC balance</span>
+                <span
+                  className={`font-mono text-sm font-semibold ${
+                    (selectedWallet.usdc_balance ?? 0) >= 2 ? "text-emerald-300" : "text-amber-300"
+                  }`}
+                >
+                  {selectedWallet.usdc_balance != null
+                    ? `$${selectedWallet.usdc_balance.toFixed(2)}`
+                    : "—"}
+                </span>
+              </div>
+            )}
+            {selectedWallet && (selectedWallet.usdc_balance ?? 0) < 2 && (
+              <p className="text-xs text-amber-300">
+                Not enough USDC for the ~$2 fee — add USDC to this agent&apos;s wallet (or swap
+                SOL&nbsp;→&nbsp;USDC) before creating the inbox.
+              </p>
+            )}
+            <div className="flex flex-col gap-2 sm:flex-row">
+              <input
+                value={username}
+                onChange={(e) => setUsername(e.target.value)}
+                placeholder="optional username (a-z, 0-9, dot, dash) — omit to auto-generate"
+                className={inputCls + " sm:flex-1"}
+              />
+            </div>
+            {createError && <p className="text-sm text-destructive">{createError}</p>}
+            {createArmed ? (
+              <div className="flex flex-wrap items-center gap-2 rounded-md border border-amber-500/40 bg-amber-500/5 p-3">
+                <span className="text-sm text-amber-200">
+                  This pays <span className="font-semibold">~$2 USDC</span> from the agent wallet.
+                  Continue?
+                </span>
+                <div className="ml-auto flex gap-2">
+                  <button
+                    type="button"
+                    onClick={() => setCreateArmed(false)}
+                    className="rounded-md px-3 py-1.5 text-sm text-muted-foreground hover:bg-muted hover:text-foreground"
+                  >
+                    Cancel
+                  </button>
+                  <Button size="sm" onClick={createInbox} disabled={creating}>
+                    {creating ? "Creating…" : "Confirm & pay"}
+                  </Button>
+                </div>
+              </div>
+            ) : (
+              <Button onClick={() => setCreateArmed(true)} disabled={creating}>
+                Create inbox
+              </Button>
+            )}
+          </CardContent>
+        </Card>
+      ) : view === "compose" ? (
+        /* ── Compose ────────────────────────────────────────────────── */
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between gap-2 pb-2">
+            <CardTitle className="text-sm font-semibold">New email</CardTitle>
+            <button
+              type="button"
+              onClick={() => setView("list")}
+              className="inline-flex items-center gap-1 text-sm text-muted-foreground hover:text-foreground"
+            >
+              <ArrowLeft className="h-4 w-4" /> Back
+            </button>
+          </CardHeader>
+          <CardContent className="space-y-3">
+            <div className="space-y-1">
+              <label className="text-xs text-muted-foreground">To</label>
+              <input
+                value={to}
+                onChange={(e) => setTo(e.target.value)}
+                placeholder="alice@example.com, bob@example.com"
+                className={inputCls}
+              />
+            </div>
+            <div className="grid gap-3 sm:grid-cols-2">
+              <div className="space-y-1">
+                <label className="text-xs text-muted-foreground">Cc (optional)</label>
+                <input value={cc} onChange={(e) => setCc(e.target.value)} className={inputCls} />
+              </div>
+              <div className="space-y-1">
+                <label className="text-xs text-muted-foreground">Bcc (optional)</label>
+                <input value={bcc} onChange={(e) => setBcc(e.target.value)} className={inputCls} />
+              </div>
+            </div>
+            <div className="space-y-1">
+              <label className="text-xs text-muted-foreground">Subject</label>
+              <input
+                value={subject}
+                onChange={(e) => setSubject(e.target.value)}
+                className={inputCls}
+              />
+            </div>
+            <div className="space-y-1">
+              <label className="text-xs text-muted-foreground">Message</label>
+              <textarea
+                value={bodyText}
+                onChange={(e) => setBodyText(e.target.value)}
+                rows={10}
+                className={inputCls + " resize-y font-sans"}
+              />
+            </div>
+            <div className="space-y-1">
+              <label className="text-xs text-muted-foreground">Reply-To (optional)</label>
+              <input
+                value={replyTo}
+                onChange={(e) => setReplyTo(e.target.value)}
+                className={inputCls}
+              />
+            </div>
+
+            {sendError && <p className="text-sm text-destructive">{sendError}</p>}
+
+            {sendArmed ? (
+              <div className="flex flex-wrap items-center gap-2 rounded-md border border-amber-500/40 bg-amber-500/5 p-3">
+                <span className="text-sm text-amber-200">
+                  Send a real email from{" "}
+                  <span className="font-mono">{inbox?.emailAddress}</span> to{" "}
+                  {recipients.length} recipient{recipients.length === 1 ? "" : "s"}? Any per-send
+                  fee is paid in USDC from the agent wallet.
+                </span>
+                <div className="ml-auto flex gap-2">
+                  <button
+                    type="button"
+                    onClick={() => setSendArmed(false)}
+                    className="rounded-md px-3 py-1.5 text-sm text-muted-foreground hover:bg-muted hover:text-foreground"
+                  >
+                    Cancel
+                  </button>
+                  <Button
+                    size="sm"
+                    prefix={<Send className="h-4 w-4" />}
+                    onClick={sendMail}
+                    disabled={sending}
+                  >
+                    {sending ? "Sending…" : "Send now"}
+                  </Button>
+                </div>
+              </div>
+            ) : (
+              <Button
+                prefix={<Send className="h-4 w-4" />}
+                onClick={() => {
+                  setSendError(null);
+                  setSendArmed(true);
+                }}
+                disabled={sending}
+              >
+                Send
+              </Button>
+            )}
+          </CardContent>
+        </Card>
+      ) : view === "read" && selected ? (
+        /* ── Read one message ───────────────────────────────────────── */
+        <Card>
+          <CardHeader className="space-y-2 pb-2">
+            <button
+              type="button"
+              onClick={() => setView("list")}
+              className="inline-flex w-fit items-center gap-1 text-sm text-muted-foreground hover:text-foreground"
+            >
+              <ArrowLeft className="h-4 w-4" /> Back to inbox
+            </button>
+            <CardTitle className="text-base font-semibold">
+              {selected.subject || "(no subject)"}
+            </CardTitle>
+            <div className="space-y-0.5 text-xs text-muted-foreground">
+              <div>
+                <Badge
+                  tone={selected.direction === "inbound" ? "secondary" : "success"}
+                  className="mr-2"
+                >
+                  {selected.direction === "inbound" ? "received" : "sent"}
+                </Badge>
+                {formatDate(selected.agentmailCreatedAt || selected.createdAt)}
+              </div>
+              {selected.fromAddress && (
+                <div>
+                  <span className="text-foreground/70">From:</span> {selected.fromAddress}
+                </div>
+              )}
+              {selected.toAddresses?.length > 0 && (
+                <div>
+                  <span className="text-foreground/70">To:</span> {selected.toAddresses.join(", ")}
+                </div>
+              )}
+              {selected.ccAddresses?.length > 0 && (
+                <div>
+                  <span className="text-foreground/70">Cc:</span> {selected.ccAddresses.join(", ")}
+                </div>
+              )}
+            </div>
+          </CardHeader>
+          <CardContent>
+            {selectedLoading ? (
+              <div className="flex justify-center py-8">
+                <Spinner />
+              </div>
+            ) : selected.textBody ? (
+              <pre className="whitespace-pre-wrap break-words font-sans text-sm text-foreground/90">
+                {selected.textBody}
+              </pre>
+            ) : selected.htmlBody ? (
+              <iframe
+                title="email body"
+                sandbox=""
+                srcDoc={selected.htmlBody}
+                className="h-[60vh] w-full rounded-md border border-border bg-white"
+              />
+            ) : (
+              <p className="text-sm text-muted-foreground">{selected.preview || "(empty message)"}</p>
+            )}
+          </CardContent>
+        </Card>
+      ) : (
+        /* ── Inbox list ─────────────────────────────────────────────── */
+        <div className="space-y-3">
+          <div className="flex gap-1">
+            {(["all", "inbound", "outbound"] as Filter[]).map((f) => (
+              <button
+                key={f}
+                type="button"
+                onClick={() => setFilter(f)}
+                className={`rounded-md px-3 py-1.5 text-sm transition-colors ${
+                  filter === f
+                    ? "bg-muted font-medium text-foreground"
+                    : "text-muted-foreground hover:bg-muted/50 hover:text-foreground"
+                }`}
+              >
+                {f === "all" ? "All" : f === "inbound" ? "Inbox" : "Sent"}
+              </button>
+            ))}
+          </div>
+
+          {messagesError && (
+            <Card className="border-destructive/40">
+              <CardContent className="py-3 text-sm text-destructive">{messagesError}</CardContent>
+            </Card>
+          )}
+
+          {messagesLoading ? (
+            <div className="flex justify-center py-12">
+              <Spinner />
+            </div>
+          ) : messages.length === 0 ? (
+            <Card>
+              <CardContent className="py-8 text-center text-sm text-muted-foreground">
+                No messages yet.
+              </CardContent>
+            </Card>
+          ) : (
+            <div className="space-y-2">
+              {messages.map((m) => {
+                const who =
+                  m.direction === "inbound"
+                    ? m.fromAddress || "unknown sender"
+                    : `To: ${m.toAddresses?.join(", ") || "—"}`;
+                return (
+                  <button
+                    key={m.id}
+                    type="button"
+                    onClick={() => openMessage(m)}
+                    className="w-full rounded-lg border border-border bg-background p-3 text-left transition-colors hover:border-primary/50 hover:bg-muted/30"
+                  >
+                    <div className="flex items-center justify-between gap-2">
+                      <div className="flex min-w-0 items-center gap-2">
+                        {m.direction === "inbound" ? (
+                          <Inbox className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        ) : (
+                          <Send className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        )}
+                        <span
+                          className={`truncate text-sm ${
+                            m.direction === "inbound" && !m.read
+                              ? "font-semibold text-foreground"
+                              : "text-foreground/80"
+                          }`}
+                        >
+                          {who}
+                        </span>
+                      </div>
+                      <span className="shrink-0 text-xs text-muted-foreground">
+                        {formatDate(m.agentmailCreatedAt || m.createdAt)}
+                      </span>
+                    </div>
+                    <div className="mt-1 truncate text-sm text-foreground/90">
+                      {m.subject || "(no subject)"}
+                    </div>
+                    {m.preview && (
+                      <div className="mt-0.5 truncate text-xs text-muted-foreground">
+                        {m.preview}
+                      </div>
+                    )}
+                  </button>
+                );
+              })}
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

package/agent/web/src/pages/WalletPage.tsx

@@ -1,8 +1,10 @@
 import { useCallback, useEffect, useState } from "react";
-import { Check, Copy, RefreshCw, Send, Wallet, X } from "lucide-react";
+import { useNavigate } from "react-router-dom";
+import { Check, Coins, Copy, RefreshCw, Send, Wallet, X } from "lucide-react";
 import { api } from "@/lib/api";
 import type { AgentWalletBalance } from "@/lib/api";
 import { Button } from "@nous-research/ui/ui/components/button";
+import { Badge } from "@nous-research/ui/ui/components/badge";
 import { Spinner } from "@nous-research/ui/ui/components/spinner";
 import {
   Card,
@@ -11,6 +13,23 @@ import {
   CardTitle,
 } from "@nous-research/ui/ui/components/card";
 
+function AgentAvatar({ url }: { url?: string | null }) {
+  // ``url`` is a signed avatar URL when the agent has one, else null → fall
+  // back to the ClawPump claw so every card shows a real logo.
+  return (
+    <img
+      src={url || "/claw-logo.png"}
+      alt=""
+      className="h-7 w-7 shrink-0 rounded-full border border-border bg-background object-cover"
+    />
+  );
+}
+
+function tokenizePrompt(w: AgentWalletBalance): string {
+  const name = w.name || w.agent_id;
+  return `Launch a ClawPump token for my agent "${name}" (agent_id ${w.agent_id}). Ask me for the ticker/symbol and any details you need, then launch it.`;
+}
+
 /* ── Token logos (inline SVG, no network) ─────────────────────────────── */
 
 function SolLogo({ className = "h-5 w-5" }: { className?: string }) {
@@ -277,6 +296,7 @@ export default function WalletPage() {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [transfer, setTransfer] = useState<AgentWalletBalance | null>(null);
+  const navigate = useNavigate();
 
   const load = useCallback(() => {
     setLoading(true);
@@ -296,6 +316,7 @@ export default function WalletPage() {
   }, []);
 
   useEffect(() => {
+    // eslint-disable-next-line react-hooks/set-state-in-effect
     load();
   }, [load]);
 
@@ -334,13 +355,27 @@ export default function WalletPage() {
           </CardContent>
         </Card>
       ) : (
-        <div className="space-y-3">
+        <div className="grid gap-3 sm:grid-cols-2">
           {wallets.map((w) => (
             <Card key={w.agent_id}>
               <CardHeader className="flex flex-row items-center justify-between gap-2 pb-2">
-                <CardTitle className="truncate text-sm font-semibold">
-                  {w.name || shortAddress(w.agent_id)}
-                </CardTitle>
+                <div className="flex min-w-0 items-center gap-2">
+                  <AgentAvatar url={w.avatar_url} />
+                  <CardTitle className="truncate text-sm font-semibold">
+                    {w.name || shortAddress(w.agent_id)}
+                  </CardTitle>
+                  {w.token_mint && (
+                    <a
+                      href={`https://solscan.io/token/${w.token_mint}`}
+                      target="_blank"
+                      rel="noreferrer"
+                      title={w.token_mint}
+                      className="shrink-0"
+                    >
+                      <Badge tone="success">tokenized</Badge>
+                    </a>
+                  )}
+                </div>
                 {w.wallet_address && (
                   <Button
                     outlined
@@ -383,6 +418,19 @@ export default function WalletPage() {
                     </div>
                   </div>
                 </div>
+                {!w.token_mint && (
+                  <Button
+                    outlined
+                    size="sm"
+                    className="w-full"
+                    onClick={() =>
+                      navigate(`/chat?prompt=${encodeURIComponent(tokenizePrompt(w))}`)
+                    }
+                    prefix={<Coins className="h-4 w-4" />}
+                  >
+                    Tokenize this agent
+                  </Button>
+                )}
               </CardContent>
             </Card>
           ))}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawpump/claw-agent",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "publishConfig": {
     "access": "public"
   },