@clawpump/claw-agent 0.1.8 → 0.1.11

package/agent/hermes_cli/gui_uninstall.py

@@ -70,21 +70,21 @@ def _agent_root(hermes_home: Path) -> Path:
 def desktop_userdata_dir() -> Path:
     """Return the Electron ``userData`` directory for the desktop app.
 
-    Mirrors Electron's ``app.getPath('userData')`` for an app named "Hermes"
+    Mirrors Electron's ``app.getPath('userData')`` for an app named "Claw Agent"
     on each platform. This is GUI-only state (connection.json, updates.json,
     Chromium cache) and never holds agent config or sessions.
     """
     home = Path.home()
     if sys.platform == "darwin":
-        return home / "Library" / "Application Support" / "Hermes"
+        return home / "Library" / "Application Support" / "Claw Agent"
     if sys.platform == "win32":
         appdata = os.environ.get("APPDATA")
         base = Path(appdata) if appdata else (home / "AppData" / "Roaming")
-        return base / "Hermes"
+        return base / "Claw Agent"
     # Linux / other POSIX — XDG config home.
     xdg = os.environ.get("XDG_CONFIG_HOME")
     base = Path(xdg) if xdg else (home / ".config")
-    return base / "Hermes"
+    return base / "Claw Agent"
 
 
 def source_built_gui_artifacts(hermes_home: Path) -> "list[Path]":
@@ -119,6 +119,9 @@ def packaged_gui_app_paths() -> "list[Path]":
     paths: list[Path] = []
     if sys.platform == "darwin":
         paths += [
+            Path("/Applications/Claw Agent.app"),
+            home / "Applications" / "Claw Agent.app",
+            # Legacy bundle name (older local builds) — clean up if present.
             Path("/Applications/Hermes.app"),
             home / "Applications" / "Hermes.app",
         ]
@@ -126,14 +129,16 @@ def packaged_gui_app_paths() -> "list[Path]":
         local = os.environ.get("LOCALAPPDATA")
         local_base = Path(local) if local else (home / "AppData" / "Local")
         paths += [
-            # NSIS per-user install (perMachine=false → Programs\Hermes).
-            local_base / "Programs" / "Hermes",
+            # NSIS per-user install (perMachine=false → Programs\Claw Agent).
+            local_base / "Programs" / "Claw Agent",
+            local_base / "Programs" / "Hermes",  # legacy
             # Older / alternate layout some builds used.
             local_base / "hermes-desktop",
         ]
         program_files = os.environ.get("ProgramFiles")
         if program_files:
             # NSIS per-machine fallback (needs admin to remove).
+            paths.append(Path(program_files) / "Claw Agent")
             paths.append(Path(program_files) / "Hermes")
     else:
         # Linux: AppImage is a single file the user placed somewhere; we can

package/agent/hermes_cli/main.py

@@ -5003,19 +5003,24 @@ def _desktop_packaged_executable(desktop_dir: Path) -> Optional[Path]:
     """Return the current platform's unpacked Electron app executable."""
     release_dir = desktop_dir / "release"
     if sys.platform == "darwin":
-        candidates = list(release_dir.glob("mac*/Hermes.app/Contents/MacOS/Hermes"))
+        # Renamed bundle "Claw Agent.app" (binary MacOS/Claw Agent); keep the
+        # legacy "Hermes.app" as a fallback for older local builds.
+        candidates = list(release_dir.glob("mac*/Claw Agent.app/Contents/MacOS/Claw Agent"))
+        candidates += list(release_dir.glob("mac*/Hermes.app/Contents/MacOS/Hermes"))
     elif sys.platform == "win32":
         candidates = [
+            release_dir / "win-unpacked" / "Claw Agent.exe",
+            release_dir / "win-ia32-unpacked" / "Claw Agent.exe",
+            release_dir / "win-arm64-unpacked" / "Claw Agent.exe",
             release_dir / "win-unpacked" / "Hermes.exe",
-            release_dir / "win-ia32-unpacked" / "Hermes.exe",
-            release_dir / "win-arm64-unpacked" / "Hermes.exe",
         ]
     else:
         candidates = [
+            release_dir / "linux-unpacked" / "claw-agent",
             release_dir / "linux-unpacked" / "hermes",
             release_dir / "linux-unpacked" / "Hermes",
+            release_dir / "linux-arm64-unpacked" / "claw-agent",
             release_dir / "linux-arm64-unpacked" / "hermes",
-            release_dir / "linux-arm64-unpacked" / "Hermes",
         ]
 
     existing = [p for p in candidates if p.exists()]

package/agent/hermes_cli/providers.py

@@ -731,4 +731,33 @@ def resolve_provider_full(
     except Exception:
         pass
 
+    # 4. Plugin model providers (providers/ registry, e.g. usepod). Not in
+    #    models.dev or the built-in alias table, so synthesize a ProviderDef
+    #    from the plugin's ProviderProfile. Without this the live model-switch
+    #    path ("Unknown provider 'usepod'") rejects any plugin api-key provider
+    #    even though it's fully configured and serving models.
+    try:
+        from providers import get_provider_profile
+
+        prof = get_provider_profile(canonical) or get_provider_profile(raw)
+        if prof is not None:
+            env_vars = tuple(getattr(prof, "env_vars", ()) or ())
+            # First env var is the API key; a trailing *_BASE_URL is the
+            # optional custom-endpoint override.
+            key_envs = tuple(e for e in env_vars if not e.upper().endswith("_BASE_URL")) or env_vars[:1]
+            base_env = next((e for e in env_vars if e.upper().endswith("_BASE_URL")), "")
+            transport = "anthropic_messages" if getattr(prof, "api_mode", "") == "anthropic_messages" else "openai_chat"
+            return ProviderDef(
+                id=canonical,
+                name=getattr(prof, "display_name", "") or getattr(prof, "name", canonical),
+                transport=transport,
+                api_key_env_vars=key_envs,
+                base_url=getattr(prof, "base_url", "") or "",
+                base_url_env_var=base_env,
+                auth_type=getattr(prof, "auth_type", "api_key") or "api_key",
+                source="plugin",
+            )
+    except Exception:
+        pass
+
     return None

package/agent/hermes_cli/web_server.py

@@ -12097,13 +12097,21 @@ 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:
+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
 
@@ -12123,9 +12131,14 @@ def _clawpump_call(tool: str, arguments: Optional[dict] = None, *, timeout: floa
             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
 
-        data = _parse_mcp_json(_run_on_mcp_loop(_coro, timeout=timeout))
+        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
@@ -12186,6 +12199,171 @@ def get_wallet_balances():
     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

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/install.sh

@@ -172,7 +172,7 @@ while [[ $# -gt 0 ]]; do
             echo "  --stage NAME   Run one desktop bootstrap stage"
             echo "  --json         Print a JSON result frame for --stage"
             echo "  --non-interactive  Skip stages that require user input"
-            echo "  --include-desktop  Also build the desktop app (apps/desktop -> Hermes.app)"
+            echo "  --include-desktop  Also build the desktop app (apps/desktop -> Claw Agent.app)"
             echo "  --dir PATH     Installation directory"
             echo "                   default (non-root):  ~/.hermes/hermes-agent"
             echo "                   default (root, Linux): /usr/local/lib/hermes-agent"
@@ -2579,6 +2579,8 @@ install_desktop() {
     else
         local cand
         for cand in \
+            "$desktop_dir/release/mac-arm64/Claw Agent.app" \
+            "$desktop_dir/release/mac/Claw Agent.app" \
             "$desktop_dir/release/mac-arm64/Hermes.app" \
             "$desktop_dir/release/mac/Hermes.app"; do
             if [ -d "$cand" ]; then

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/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,
   );

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

@@ -0,0 +1,57 @@
+import { useEffect, useRef, useState } from "react";
+import { api } from "@/lib/api";
+
+/**
+ * Compact "Pod $X.XX" credits pill, shown next to the model badge only when the
+ * active provider is UsePod (Pod). Polls /api/clawpump/pod/status; keeps the
+ * last value so a transient probe failure never blanks it. Mirrors the desktop
+ * PodCredits.
+ */
+export default function PodCredits({ provider }: { provider: string }) {
+  const isPod = provider === "usepod";
+  const [balance, setBalance] = useState<number | null>(null);
+  const [connected, setConnected] = useState(false);
+  const lastBalance = useRef<number | null>(null);
+
+  useEffect(() => {
+    if (!isPod) return;
+    let cancelled = false;
+    const tick = () => {
+      void api
+        .getPodStatus()
+        .then((r) => {
+          if (cancelled) return;
+          setConnected(!!r.connected);
+          if (r.balance_usdc != null) {
+            lastBalance.current = r.balance_usdc;
+            setBalance(r.balance_usdc);
+          } else if (lastBalance.current != null) {
+            setBalance(lastBalance.current);
+          }
+        })
+        .catch(() => undefined);
+    };
+    tick();
+    const id = window.setInterval(tick, 60_000);
+    return () => {
+      cancelled = true;
+      window.clearInterval(id);
+    };
+  }, [isPod]);
+
+  if (!isPod || !connected) return null;
+
+  const low = balance != null && balance < 0.5;
+  return (
+    <span
+      title={balance != null ? `Pod credits: $${balance.toFixed(4)} USDC` : "Pod connected"}
+      className={`inline-flex shrink-0 items-center gap-1 rounded-md border px-1.5 py-0.5 text-[0.6875rem] font-medium ${
+        low
+          ? "border-amber-500/40 bg-amber-500/10 text-amber-300"
+          : "border-emerald-500/30 bg-emerald-500/10 text-emerald-300"
+      }`}
+    >
+      ⚡ {balance != null ? `$${balance.toFixed(2)}` : "Pod"}
+    </span>
+  );
+}