@clawpump/claw-agent 0.1.7 → 0.1.9

package/agent/hermes_cli/web_server.py

@@ -12081,52 +12081,289 @@ 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, prefer_structured: bool = False
+) -> 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.
+
+    ``prefer_structured`` returns the tool's ``structuredContent`` (the machine
+    channel) when present, instead of the human-visible text. Needed for tools
+    that REDACT secrets in the text but put the real value in structuredContent
+    (e.g. usepod_provision returns a placeholder api_token in text and the real
+    token in structuredContent). Default off so existing callers are unchanged.
+    """
+    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")
+            if prefer_structured:
+                sc = getattr(result, "structuredContent", None)
+                if isinstance(sc, dict) and sc:
+                    return sc
+            return text
+
+        raw = _run_on_mcp_loop(_coro, timeout=timeout)
+        data = raw if isinstance(raw, dict) else _parse_mcp_json(raw)
+        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
 
     return {"ok": True, "wallets": wallets}
 
 
+class PodProvisionBody(BaseModel):
+    agent_id: str
+    amount: float
+
+
+@app.post("/api/clawpump/pod/provision")
+async def post_pod_provision(body: PodProvisionBody, profile: Optional[str] = None):
+    """Provision a UsePod "Pod" and switch the agent onto it as the provider.
+
+    One ClawPump-wallet-funded call: ``usepod_provision`` registers a fresh pod
+    and funds it with ``amount`` USDC from ``agent_id``'s wallet (double-gated by
+    ``confirm_deposit``), returning an ``api_token``. We persist the token
+    (USEPOD_API_KEY) and set ``model.provider=usepod`` so the session uses Pod —
+    the desktop's one-click "Set up Pod" flow, mirroring the CLI Pod picker.
+
+    Spends real on-chain USDC; the UI confirms the amount before calling this.
+    Sync body runs in a worker thread (MCP + ``_profile_scope`` both block).
+    """
+    agent_id = (body.agent_id or "").strip()
+    try:
+        amount = float(body.amount)
+    except (TypeError, ValueError):
+        raise HTTPException(status_code=400, detail="amount must be a number")
+    if not agent_id:
+        raise HTTPException(status_code=400, detail="agent_id is required")
+    if amount <= 0:
+        raise HTTPException(status_code=400, detail="amount must be positive")
+
+    def _unwrap(value: "Any") -> "Any":
+        # ClawPump MCP results can arrive double-wrapped: {"result": "<escaped
+        # json>"} or {"structuredContent": {...}}. Peel those so we see the real
+        # {api_token, deposit_code, signature, funding_error} object.
+        seen = 0
+        while isinstance(value, str) and seen < 3:
+            try:
+                value = json.loads(value)
+                seen += 1
+            except Exception:
+                break
+        if isinstance(value, dict):
+            sc = value.get("structuredContent")
+            if isinstance(sc, dict):
+                return sc
+            if set(value.keys()) <= {"result"} and value.get("result") is not None:
+                return _unwrap(value["result"])
+        return value
+
+    def _provision_and_apply():
+        from hermes_cli import distribution as _dist
+
+        raw = _clawpump_call(
+            "usepod_provision",
+            {"amount": amount, "agent_id": agent_id, "confirm_deposit": True},
+            timeout=120,
+            # The real api_token is only in structuredContent — the text channel
+            # redacts it to a placeholder. Without this we'd persist the
+            # placeholder as USEPOD_API_KEY and Pod would look set but not work.
+            prefer_structured=True,
+        )
+        # Token extraction goes through the battle-tested downstream helper
+        # (tolerates nesting/escaping); signature is best-effort from _unwrap.
+        tok = _dist.usepod_provision_token("mcp_clawpump_usepod_provision", raw)
+        data = _unwrap(raw)
+        data = data if isinstance(data, dict) else {}
+        if tok:
+            api_token, deposit_code = tok
+        else:
+            api_token = str(data.get("api_token") or data.get("token") or "").strip()
+            deposit_code = str(data.get("deposit_code") or "").strip()
+        if not api_token:
+            detail = str(data.get("funding_error") or data.get("error") or "no api_token returned")
+            raise RuntimeError(f"Pod provisioning failed: {detail}")
+
+        _dist.persist_usepod_credentials(api_token, deposit_code)
+
+        current = ""
+        try:
+            from hermes_cli.config import load_config
+
+            current = str((load_config().get("model") or {}).get("default") or "")
+        except Exception:
+            current = ""
+        model, _provider, _base_url = _dist.usepod_pod_switch_target(api_token, current)
+        with _profile_scope(body.profile if hasattr(body, "profile") else profile):
+            _apply_model_assignment_sync("main", "usepod", model, "", "", "")
+
+        return {
+            "ok": True,
+            "provider": "usepod",
+            "model": model,
+            "amount": amount,
+            "signature": str(data.get("signature") or ""),
+            "funding_error": str(data.get("funding_error") or ""),
+        }
+
+    try:
+        return await asyncio.to_thread(_provision_and_apply)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        _log.exception("POST /api/clawpump/pod/provision failed")
+        return {"ok": False, "error": str(exc)}
+
+
+# Last successfully-fetched Pod balance, keyed by token. A transient probe
+# failure (Cloudflare hiccup / timeout) then falls back to the last good value
+# so the UI never flickers from "$0.96" back to a bare "Pod". {token: usdc}.
+_pod_balance_cache: Dict[str, float] = {}
+
+
+def _fetch_pod_balance(token: str) -> Optional[float]:
+    """Fetch the pod's USDC balance (UI units). Retries once; None on failure."""
+    from hermes_cli.auth import USEPOD_API_BASE
+    from providers.base import _profile_user_agent
+
+    url = f"{USEPOD_API_BASE}/proxy/{token}/balance"
+    for attempt in range(2):
+        try:
+            # UsePod sits behind Cloudflare, which 403s ("error 1010") a bare
+            # urllib request — send a browser-ish UA + the bearer token, matching
+            # the provider's own fetch_models. The token also lives in the path.
+            req = urllib.request.Request(url, method="GET")
+            req.add_header("User-Agent", _profile_user_agent())
+            req.add_header("Authorization", f"Bearer {token}")
+            req.add_header("Accept", "application/json")
+            with urllib.request.urlopen(req, timeout=8) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+            micro = data.get("usdc_balance")
+            if micro is not None:
+                return round(float(micro) / 1_000_000.0, 4)
+            return None
+        except Exception:
+            if attempt == 0:
+                continue
+            return None
+    return None
+
+
+@app.get("/api/clawpump/pod/status")
+def get_pod_status():
+    """Whether a UsePod Pod is configured + its remaining USDC balance.
+
+    Lets the desktop show Pod as "Connected" (with balance) instead of "Set up"
+    once provisioned. Reads USEPOD_API_KEY from ~/.hermes/.env (never returns the
+    token) and best-effort fetches the pod's balance — falling back to the last
+    cached value on a transient failure so the credits readout stays stable.
+    """
+    from hermes_cli.config import get_env_value
+
+    token = (get_env_value("USEPOD_API_KEY") or "").strip()
+    # Empty, or the redacted placeholder from the old token-handling bug, both
+    # mean "not really connected".
+    if not token or token.startswith("<") or "applied" in token.lower():
+        return {"connected": False}
+
+    balance_usdc = _fetch_pod_balance(token)
+    if balance_usdc is not None:
+        _pod_balance_cache[token] = balance_usdc
+    else:
+        # Probe failed this time — show the last known balance if we have one.
+        balance_usdc = _pod_balance_cache.get(token)
+
+    return {"connected": True, "balance_usdc": balance_usdc}
+
+
 class WalletTransferBody(BaseModel):
     agent_id: str
     to: str
@@ -12196,31 +12433,16 @@ def x402_search(q: str = "", network: str = "solana"):
     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": "", "network": network, "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": [],
-        }
-
     try:
-        text = _call_single_tool(
-            srv_name, srv_cfg, "dexter_search", {"query": query, "network": network}
-        )
+        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):
@@ -12230,6 +12452,153 @@ def x402_search(q: str = "", network: str = "solana"):
     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"
 _FONT_CHOICES = frozenset({
     "system-sans", "system-serif", "system-mono",

package/agent/plugins/model-providers/usepod/__init__.py

@@ -39,13 +39,19 @@ USEPOD_API_BASE = "https://api.usepod.ai"
 class UsePodProfile(ProviderProfile):
     """UsePod — OpenAI-compatible proxy with the auth token in the URL path."""
 
-    def fetch_models(self, *, api_key: str | None = None, timeout: float = 8.0):
+    def fetch_models(self, *, api_key: str | None = None, base_url: str | None = None, timeout: float = 8.0):
         """List models from the per-token catalog endpoint.
 
         UsePod exposes ``/proxy/<token>/v1/models``; the token lives in the
         path, so the base-class implementation (which builds the URL from the
         static ``base_url``) cannot reach it. Returns None when no token is
         available so callers fall back to ``fallback_models``.
+
+        ``base_url`` is accepted (and ignored — the URL is derived from the
+        token) only so the generic picker fetch in ``models.provider_model_ids``
+        — which calls ``fetch_models(api_key=…, base_url=…)`` for every api-key
+        provider — doesn't raise a TypeError. That TypeError was silently
+        swallowed, leaving UsePod with zero models in the picker. (#pod-models)
         """
         token = (api_key or "").strip()
         if not token:

package/agent/scripts/release.py

@@ -46,6 +46,7 @@ ACP_REGISTRY_MANIFEST = REPO_ROOT / "acp_registry" / "agent.json"
 # Auto-extracted from noreply emails + manual overrides
 AUTHOR_MAP = {
     "chris@100x.dev": "chris-gilbert",
+    "0xtomi204@gmail.com": "tomi204",  # ClawPump maintainer (Tomas Oliver)
     "charles@salesondemand.io": "salesondemandio",
     "victor@rocketfueldev.com": "victor-kyriazakos",
     "87440198+JoaoMarcos44@users.noreply.github.com": "JoaoMarcos44",

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/components/ChatSidebar.tsx

@@ -29,6 +29,7 @@ import { Badge } from "@nous-research/ui/ui/components/badge";
 import { Card } from "@nous-research/ui/ui/components/card";
 
 import { ModelPickerDialog } from "@/components/ModelPickerDialog";
+import PodCredits from "@/components/PodCredits";
 import { ModelReloadConfirm } from "@/components/ModelReloadConfirm";
 import { ReasoningPicker } from "@/components/ReasoningPicker";
 import { ToolCall, type ToolEntry } from "@/components/ToolCall";
@@ -121,6 +122,7 @@ export function ChatSidebar({
   // elsewhere, so the badge would go stale. `/api/model/info` is profile-scoped
   // by `fetchJSON`, so it reads the same profile this sidebar is scoped to.
   const [effectiveModel, setEffectiveModel] = useState("");
+  const [effectiveProvider, setEffectiveProvider] = useState("");
   // Whether the effective model supports reasoning effort — gates the
   // ReasoningPicker. Read from the same `/api/model/info` capabilities the
   // (currently unused) ModelInfoCard surfaces, so the dashboard exposes a
@@ -143,6 +145,7 @@ export function ChatSidebar({
       .getModelInfo()
       .then((r) => {
         if (r?.model) setEffectiveModel(String(r.model));
+        setEffectiveProvider(r?.provider ? String(r.provider) : "");
         setSupportsReasoning(!!r?.capabilities?.supports_reasoning);
         // Bump so ReasoningPicker re-reads the saved effort for the new model.
         setModelRefreshKey((k) => k + 1);
@@ -449,6 +452,8 @@ export function ChatSidebar({
           </span>
         </Button>
 
+        <PodCredits provider={effectiveProvider} />
+
         <Badge tone={STATE_TONE[state]} className="hidden shrink-0 md:inline-flex">
           {STATE_LABEL[state]}
         </Badge>

package/agent/web/src/components/ModelPickerDialog.tsx

@@ -5,8 +5,9 @@ import { Spinner } from "@nous-research/ui/ui/components/spinner";
 import { Input } from "@nous-research/ui/ui/components/input";
 import { Label } from "@nous-research/ui/ui/components/label";
 import { ConfirmDialog } from "@/components/ConfirmDialog";
+import PodSetupDialog from "@/components/PodSetupDialog";
 import type { GatewayClient } from "@/lib/gatewayClient";
-import { Check, Search, X } from "lucide-react";
+import { Check, Search, X, Zap } from "lucide-react";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { cn, themedBody } from "@/lib/utils";
@@ -110,6 +111,7 @@ export function ModelPickerDialog(props: Props) {
   const [selectedModel, setSelectedModel] = useState("");
   const [query, setQuery] = useState("");
   const [persistGlobal, setPersistGlobal] = useState(alwaysGlobal);
+  const [podOpen, setPodOpen] = useState(false);
   const [applying, setApplying] = useState(false);
   const [pendingConfirm, setPendingConfirm] =
     useState<PendingExpensiveConfirm | null>(null);
@@ -366,6 +368,13 @@ export function ModelPickerDialog(props: Props) {
         </div>
 
         <footer className="border-t border-border p-3 flex items-center justify-between gap-3 flex-wrap">
+          <Button
+            outlined
+            onClick={() => setPodOpen(true)}
+            className="gap-1.5"
+          >
+            <Zap className="h-3.5 w-3.5 text-primary" /> Set up Pod
+          </Button>
           {alwaysGlobal ? (
             <span className="text-xs text-muted-foreground">
               Saves to config.yaml — applies to new sessions.
@@ -415,6 +424,24 @@ export function ModelPickerDialog(props: Props) {
           void applySelection(true, pending);
         }}
       />
+      {podOpen && (
+        <PodSetupDialog
+          onClose={() => setPodOpen(false)}
+          onProvisioned={(model) => {
+            // Called from the dialog's "Pod ready" → Done. Backend already set
+            // provider=usepod + model in config; switch the live session too
+            // (slash in chat mode / onApply in standalone). applySelection calls
+            // onClose() → that unmounts this dialog and the whole picker.
+            setPodOpen(false);
+            void applySelection(false, {
+              message: "",
+              model,
+              persistGlobal: true,
+              provider: "usepod",
+            });
+          }}
+        />
+      )}
     </div>,
     document.body,
   );