@clawpump/claw-agent 0.1.7 → 0.1.9

package/agent/apps/desktop/src/store/onboarding.ts

@@ -189,7 +189,7 @@ async function checkRuntime(ctx: OnboardingContext): Promise<RuntimeReadinessRes
 }
 
 function notifyReady(provider: string) {
-  notify({ kind: 'success', title: 'Hermes is ready', message: `${provider} connected.` })
+  notify({ kind: 'success', title: 'Claw Agent is ready', message: `${provider} connected.` })
 }
 
 // Human-friendly labels for tools auto-routed through the Nous Tool Gateway,
@@ -360,8 +360,8 @@ function providerResolutionFailure(reason: null | string) {
   const detail = reason?.trim()
 
   return detail
-    ? `Connected, but Hermes still cannot resolve a usable provider. ${detail}`
-    : 'Connected, but Hermes still cannot resolve a usable provider.'
+    ? `Connected, but Claw Agent still cannot resolve a usable provider. ${detail}`
+    : 'Connected, but Claw Agent still cannot resolve a usable provider.'
 }
 
 async function refreshProviders() {
@@ -722,7 +722,7 @@ export async function recheckExternalSignin(ctx: OnboardingContext) {
       provider,
       message:
         reason?.trim() ||
-        `Hermes still cannot reach ${provider.name}. Run \`${provider.cli_command}\` in a terminal first.`
+        `Claw Agent still cannot reach ${provider.name}. Run \`${provider.cli_command}\` in a terminal first.`
     })
   )
 }
@@ -837,7 +837,7 @@ export async function saveOnboardingLocalEndpoint(baseUrl: string, apiKey: strin
     if (!runtime.ready) {
       const detail = (runtime.reason ?? '').trim()
 
-      return { ok: false, message: detail || `Saved, but Hermes still cannot reach ${url}.` }
+      return { ok: false, message: detail || `Saved, but Claw Agent still cannot reach ${url}.` }
     }
 
     notifyReady('Local / custom endpoint')

package/agent/apps/desktop/src/themes/presets.ts

@@ -21,75 +21,75 @@ const SYSTEM_MONO =
 
 export const DEFAULT_TYPOGRAPHY: DesktopThemeTypography = { fontSans: SYSTEM_SANS, fontMono: SYSTEM_MONO }
 
-const NOUS_BLUE = '#0053FD'
-const PSYCHE_BLUE = '#1540B1'
-const PSYCHE_WARM = '#FFE6CB'
+const CLAW_GREEN = '#22C55E'
+const CLAW_GREEN_LIGHT = '#4ADE80'
+const CLAW_GREEN_DEEP = '#16A34A'
 
-const nousTint = (pct: number) => `color-mix(in srgb, ${NOUS_BLUE} ${pct}%, #FFFFFF)`
-const nousTintTransparent = (pct: number) => `color-mix(in srgb, ${NOUS_BLUE} ${pct}%, transparent)`
+const clawTint = (pct: number) => `color-mix(in srgb, ${CLAW_GREEN} ${pct}%, #FFFFFF)`
+const clawTintTransparent = (pct: number) => `color-mix(in srgb, ${CLAW_GREEN} ${pct}%, transparent)`
 
 /**
- * Nous — canonical Hermes desktop identity. The palette keeps the current
- * glass geometry neutral, then lets the old bb/gui blue and psyche cream
- * return as accent seeds.
+ * Claw Agent — canonical ClawPump desktop identity (built on Hermes by Nous
+ * Research). Solana-green accents on glass neutrals in light mode, deep
+ * ClawPump green in dark mode.
  */
 export const nousTheme: DesktopTheme = {
   name: 'nous',
-  label: 'Nous',
-  description: 'Glass neutrals with Nous blue accents',
+  label: 'Claw Agent',
+  description: 'ClawPump green on glass neutrals',
   colors: {
-    background: '#F8FAFF',
-    foreground: '#17171A',
+    background: '#F6FBF8',
+    foreground: '#13201A',
     card: '#FFFFFF',
-    cardForeground: '#17171A',
-    muted: nousTint(5),
-    mutedForeground: '#666678',
+    cardForeground: '#13201A',
+    muted: clawTint(5),
+    mutedForeground: '#5B6B62',
     popover: '#FFFFFF',
-    popoverForeground: '#17171A',
-    primary: NOUS_BLUE,
-    primaryForeground: '#FCFCFC',
-    secondary: nousTint(7),
-    secondaryForeground: '#242432',
-    accent: nousTint(10),
-    accentForeground: '#202030',
-    border: nousTintTransparent(22),
-    input: nousTintTransparent(30),
-    ring: NOUS_BLUE,
-    midground: NOUS_BLUE,
-    composerRing: NOUS_BLUE,
+    popoverForeground: '#13201A',
+    primary: CLAW_GREEN,
+    primaryForeground: '#FCFFFD',
+    secondary: clawTint(7),
+    secondaryForeground: '#1E2A24',
+    accent: clawTint(10),
+    accentForeground: '#1B2620',
+    border: clawTintTransparent(22),
+    input: clawTintTransparent(30),
+    ring: CLAW_GREEN,
+    midground: CLAW_GREEN,
+    composerRing: CLAW_GREEN,
     destructive: '#C72E4D',
     destructiveForeground: '#FFFFFF',
-    sidebarBackground: '#F3F7FF',
-    sidebarBorder: nousTintTransparent(18),
-    userBubble: nousTint(6),
-    userBubbleBorder: nousTintTransparent(24)
+    sidebarBackground: '#F1FAF4',
+    sidebarBorder: clawTintTransparent(18),
+    userBubble: clawTint(6),
+    userBubbleBorder: clawTintTransparent(24)
   },
   darkColors: {
-    background: '#0D2F86',
-    foreground: PSYCHE_WARM,
-    card: '#12378F',
-    cardForeground: PSYCHE_WARM,
-    muted: '#183F9A',
-    mutedForeground: '#B5C7F3',
-    popover: '#123A96',
-    popoverForeground: PSYCHE_WARM,
-    primary: PSYCHE_WARM,
-    primaryForeground: '#0D2F86',
-    secondary: '#1B45A4',
-    secondaryForeground: '#E0E8FF',
-    accent: PSYCHE_BLUE,
-    accentForeground: '#F0F4FF',
-    border: '#3158AD',
-    input: '#0B2566',
-    ring: PSYCHE_WARM,
-    midground: NOUS_BLUE,
-    composerRing: PSYCHE_WARM,
+    background: '#0B1F14',
+    foreground: '#DCFCE7',
+    card: '#0F2A1B',
+    cardForeground: '#DCFCE7',
+    muted: '#15301F',
+    mutedForeground: '#86B89C',
+    popover: '#0F2A1B',
+    popoverForeground: '#DCFCE7',
+    primary: CLAW_GREEN_LIGHT,
+    primaryForeground: '#06140C',
+    secondary: '#173B26',
+    secondaryForeground: '#D6F5E1',
+    accent: CLAW_GREEN_DEEP,
+    accentForeground: '#ECFDF3',
+    border: '#1E5236',
+    input: '#0A1B11',
+    ring: CLAW_GREEN_LIGHT,
+    midground: CLAW_GREEN,
+    composerRing: CLAW_GREEN_LIGHT,
     destructive: '#C0473A',
     destructiveForeground: '#FEF2F2',
-    sidebarBackground: '#09286F',
-    sidebarBorder: '#234A9C',
-    userBubble: '#143B91',
-    userBubbleBorder: '#3A63BD'
+    sidebarBackground: '#081A10',
+    sidebarBorder: '#1B4A30',
+    userBubble: '#143625',
+    userBubbleBorder: '#2E6B47'
   },
   typography: {
     fontSans: SYSTEM_SANS,

package/agent/cli.py

@@ -2247,6 +2247,13 @@ def _replay_output_history() -> None:
         _OUTPUT_HISTORY_REPLAYING = False
 
 
+# Internal sentinel enqueued by the model picker to run the deterministic Pod
+# setup on the process_loop worker thread (see process_command). Not a
+# user-facing command; the leading slash makes process_loop route it to
+# process_command rather than treating it as agent chat input.
+_POD_SETUP_COMMAND = "/__clawpump_pod_setup__"
+
+
 def _cprint(text: str):
     """Print ANSI-colored text through prompt_toolkit's native renderer.
 
@@ -7009,6 +7016,147 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin):
         else:
             _cprint("    (session only — add --global to persist)")
 
+    def _run_pod_setup_flow(self) -> bool:
+        """Deterministic Pod setup (mirrors the desktop modal): pick wallet →
+        amount → confirm → provision + fund on-chain → switch onto Pod.
+
+        MUST be called on the process_loop worker thread (it is — via the
+        _POD_SETUP_COMMAND sentinel in process_command), NOT the prompt_toolkit
+        event-loop thread: it uses ``_prompt_text_input_modal`` (the app-native
+        modal billing uses) for every step, and the ~30-90s blocking provision
+        runs here without freezing the TUI (the event loop is the main thread).
+
+        Returns True when handled (success OR user cancel); False to fall back to
+        the chat-guided flow (no interactive app, MCP unavailable, no wallets).
+        """
+        if not getattr(self, "_app", None):
+            return False  # non-interactive — let the chat-guided flow handle it
+        try:
+            from hermes_cli import distribution as _dist
+        except Exception:
+            return False
+
+        try:
+            wallets = _dist.usepod_fetch_wallets()
+        except Exception:
+            logger.debug("Pod setup: wallet fetch failed", exc_info=True)
+            return False
+        if not wallets:
+            return False
+
+        # 1. Pick the funding wallet (default = most-funded, listed first).
+        wallet_choices = [
+            (
+                w["agent_id"],
+                f"{w.get('name') or (w.get('agent_id') or '')[:8]} — ${(w.get('usdc_balance') or 0):.2f} USDC",
+                "fund the pod from this wallet",
+            )
+            for w in wallets
+        ]
+        wallet_choices.append(("cancel", "Cancel", "do nothing"))
+        raw = self._prompt_text_input_modal(
+            title="⚡ Set up Pod — pay from which agent wallet?",
+            detail="Pod is pay-as-you-go inference funded from a ClawPump wallet.",
+            choices=wallet_choices,
+        )
+        agent_id = self._normalize_slash_confirm_choice(raw, wallet_choices)
+        if not agent_id or agent_id == "cancel":
+            _cprint("  🟡 Pod setup cancelled.")
+            return True
+        wallet = next((w for w in wallets if w["agent_id"] == agent_id), None)
+        if not wallet:
+            _cprint("  🟡 Pod setup cancelled.")
+            return True
+
+        # 2. Amount — preset choices (a text modal off the main thread can't
+        #    reliably read free text, so offer presets bounded by the balance).
+        bal = wallet.get("usdc_balance") or 0
+        amount_choices = [
+            (str(a), f"${a:.0f} USDC", f"fund ${a:.0f}")
+            for a in (5, 10, 25, 50)
+            if a <= bal
+        ]
+        if not amount_choices:
+            # Balance under $5 — offer the whole balance (min 0.5) or cancel.
+            usable = round(max(bal, 0), 2)
+            if usable < 0.5:
+                _cprint(f"  🔴 Wallet only holds ${bal:.2f} USDC — fund it first.")
+                return True
+            amount_choices = [(str(usable), f"${usable:.2f} USDC (full balance)", "fund the balance")]
+        amount_choices.append(("cancel", "Cancel", "do nothing"))
+        raw = self._prompt_text_input_modal(
+            title=f"⚡ Fund amount  (wallet has ${bal:.2f} USDC)",
+            detail="The pod holds a prepaid USDC balance you draw down per request.",
+            choices=amount_choices,
+        )
+        amt_choice = self._normalize_slash_confirm_choice(raw, amount_choices)
+        if not amt_choice or amt_choice == "cancel":
+            _cprint("  🟡 Pod setup cancelled.")
+            return True
+        try:
+            amount = float(amt_choice)
+            if amount <= 0:
+                raise ValueError
+        except ValueError:
+            _cprint("  🟡 Pod setup cancelled.")
+            return True
+
+        # 3. Final confirm — the on-chain spend.
+        confirm_choices = [
+            ("pay", f"Fund ${amount:.2f} & use Pod", "submit the on-chain deposit"),
+            ("cancel", "Cancel", "do not spend"),
+        ]
+        raw = self._prompt_text_input_modal(
+            title="⚡ Confirm Pod funding",
+            detail=f"Spend ${amount:.2f} USDC from '{wallet.get('name') or agent_id[:8]}' on-chain. Irreversible.",
+            choices=confirm_choices,
+        )
+        if self._normalize_slash_confirm_choice(raw, confirm_choices) != "pay":
+            _cprint("  🟡 Pod setup cancelled. No funds moved.")
+            return True
+
+        # 4. Provision + fund (blocking ~30-90s — fine on this worker thread).
+        _cprint(f"  ⚡ Provisioning Pod and funding ${amount:.2f} USDC on-chain… (~30-60s)")
+        try:
+            res = _dist.usepod_provision_call(wallet["agent_id"], amount)
+        except Exception as exc:
+            _cprint(f"  🔴 Pod setup failed: {exc}")
+            return True
+
+        api_token = res.get("api_token") or ""
+        if not api_token:
+            _cprint(f"  🔴 Pod setup failed: {res.get('funding_error') or 'no token returned'}")
+            return True
+
+        # 5. Persist + switch. Persist FIRST so a later switch error never loses
+        #    a token the user already paid for; guard the switch separately so it
+        #    can't bubble to the picker handler and double-handle as chat.
+        _dist.persist_usepod_credentials(api_token, res.get("deposit_code") or "")
+        try:
+            model, _provider, base_url = _dist.usepod_pod_switch_target(
+                api_token, getattr(self, "model", "") or ""
+            )
+            self._pending_pod_activation = {
+                "model": model,
+                "provider": "usepod",
+                "base_url": base_url,
+                "api_key": api_token,
+            }
+            self._activate_pending_pod()
+        except Exception:
+            logger.debug("Pod setup: switch failed (token persisted)", exc_info=True)
+            _cprint("  ✓ Pod funded and saved. Re-open the model picker to select a Pod model.")
+            return True
+
+        if res.get("funding_error"):
+            _cprint(
+                f"  ✓ Pod created and selected ({model}). "
+                f"⚠ funding issue: {res['funding_error']} — top it up and retry."
+            )
+        else:
+            _cprint(f"  ✓ Pod ready — funded ${amount:.2f} USDC, now using {model}.")
+        return True
+
     def _handle_model_picker_selection(self, persist_global: bool = False) -> None:
         state = self._model_picker_state
         if not state:
@@ -7027,16 +7175,16 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin):
             # failing switch. Hand the agent the configure instruction.
             if provider_data.get("clawpump_setup"):
                 self._close_model_picker()
-                try:
-                    from hermes_cli.distribution import usepod_setup_request_message
-                    _msg = usepod_setup_request_message()
-                except Exception:
-                    _msg = (
-                        "Help me set up the Pod (UsePod) provider step by step and "
-                        "fund it from my ClawPump wallet."
-                    )
+                # Run the deterministic Pod setup (pick wallet → amount → confirm
+                # → provision) on the process_loop background thread, NOT here:
+                # this handler runs on the prompt_toolkit main/event-loop thread,
+                # where the interactive curses pickers + the ~30-90s on-chain
+                # provision would freeze the TUI. Enqueuing the internal command
+                # routes it through process_command() on the worker thread — the
+                # same path the /billing interactive flow uses safely. The flow
+                # itself falls back to the chat-guided message if it can't run.
                 if hasattr(self, "_pending_input"):
-                    self._pending_input.put(_msg)
+                    self._pending_input.put(_POD_SETUP_COMMAND)
                 return
             # Use the curated model list from list_authenticated_providers()
             # (same lists as `hermes model` and gateway pickers).
@@ -7489,6 +7637,29 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin):
         cmd_lower = command.lower().strip()
         cmd_original = command.strip()
 
+        # Internal: deterministic Pod setup, enqueued by the model picker so it
+        # runs HERE on the process_loop worker thread (not the keybinding/event
+        # thread). On this thread the curses pickers do direct terminal I/O and
+        # the slow on-chain provision doesn't block the TUI event loop.
+        if cmd_original == _POD_SETUP_COMMAND:
+            try:
+                if self._run_pod_setup_flow():
+                    return True
+            except Exception:
+                logger.debug("Pod setup flow failed; falling back to chat", exc_info=True)
+            # Couldn't run deterministically — hand the agent the guided message.
+            try:
+                from hermes_cli.distribution import usepod_setup_request_message
+                _msg = usepod_setup_request_message()
+            except Exception:
+                _msg = (
+                    "Help me set up the Pod (UsePod) provider step by step and "
+                    "fund it from my ClawPump wallet."
+                )
+            if hasattr(self, "_pending_input"):
+                self._pending_input.put(_msg)
+            return True
+
         # Resolve aliases via central registry so adding an alias is a one-line
         # change in hermes_cli/commands.py instead of touching every dispatch site.
         from hermes_cli.commands import resolve_command as _resolve_cmd
@@ -14006,7 +14177,10 @@ class HermesCLI(CLIAgentSetupMixin, CLICommandsMixin):
                         continue
 
                     if not _file_drop and isinstance(user_input, str) and _looks_like_slash_command(user_input):
-                        _cprint(f"\n⚙️  {user_input}")
+                        # Internal sentinels (e.g. the Pod-setup hand-off from the
+                        # model picker) aren't user commands — don't echo them.
+                        if user_input != _POD_SETUP_COMMAND:
+                            _cprint(f"\n⚙️  {user_input}")
                         try:
                             if not self.process_command(user_input):
                                 self._should_exit = True

package/agent/hermes_cli/distribution.py

@@ -406,29 +406,49 @@ def usepod_provision_token(function_name: str, function_result: Any):
 def usepod_pod_switch_target(api_token: str, current_model: str = ""):
     """Return ``(model, provider, base_url)`` to switch onto for a Pod token.
 
-    Keeps the user's current model when UsePod's offline catalog lists it,
-    otherwise falls back to the provider's first advertised Pod model. The
-    secret-bearing base_url is derived from the token (never persisted to
-    config.yaml).
+    Keeps the user's current model only when the pod's LIVE catalog actually
+    serves it; otherwise picks a pod-served model. Using the live catalog (not
+    the static ``fallback_models``) matters: the static list includes names like
+    ``gpt-5.5`` that the pod does NOT serve, so keeping the user's old model
+    there left them on a model the pod can't run — the runtime then fell back to
+    that model's native provider (e.g. Codex) and errored. The secret-bearing
+    base_url is derived from the token (never persisted to config.yaml).
     """
     provider = "usepod"
-    models = []
+    pp = None
     try:
         from providers import get_provider_profile
 
         pp = get_provider_profile(provider)
-        models = list(getattr(pp, "fallback_models", ()) or [])
+    except Exception:
+        pp = None
+
+    # Live catalog first (what the pod really serves), then the static list.
+    models = []
+    try:
+        if pp is not None and api_token:
+            live = pp.fetch_models(api_key=api_token)
+            if live:
+                models = list(live)
     except Exception:
         models = []
+    if not models:
+        models = list(getattr(pp, "fallback_models", ()) or []) if pp else []
 
     model = ""
     cur = (current_model or "").strip()
     if cur and cur in models:
         model = cur
     elif models:
-        model = models[0]
+        # Prefer a sensible default if present, else the first served model.
+        for pref in ("claude-opus-4-8", "claude-sonnet-4-6"):
+            if pref in models:
+                model = pref
+                break
+        if not model:
+            model = models[0]
     else:
-        model = cur or "claude-opus-4-8"
+        model = "claude-opus-4-8"
 
     base_url = ""
     try:
@@ -455,3 +475,163 @@ def persist_usepod_credentials(api_token: str, deposit_code: str = "") -> bool:
         return True
     except Exception:
         return False
+
+
+# ── Deterministic Pod setup (terminal flow, mirrors the desktop modal) ─────
+# Lets the TUI run a clean "pick wallet → amount → confirm → provision" flow
+# directly, instead of injecting a chat message and asking the agent to do it.
+
+
+def _clawpump_mcp_config():
+    """Return (server_name, resolved_config) for the ClawPump MCP, or (None, None)."""
+    try:
+        from hermes_cli.mcp_config import _get_mcp_servers, _resolve_mcp_server_config
+
+        servers = _get_mcp_servers()
+        name = next((n for n in ("clawpump", "clawpump-stdio") if n in servers), None)
+        if not name:
+            return (None, None)
+        return (name, _resolve_mcp_server_config(servers[name]))
+    except Exception:
+        return (None, None)
+
+
+def _clawpump_tool_struct(tool: str, arguments=None, *, timeout: float = 120):
+    """Call a ClawPump MCP tool, returning its structuredContent when present.
+
+    Like ``mcp_config._call_single_tool`` but keeps ``structuredContent`` — the
+    machine channel where ``usepod_provision`` puts the REAL api_token (the text
+    channel redacts it). Falls back to the parsed text JSON otherwise. Blocking.
+    """
+    import json as _json
+
+    name, config = _clawpump_mcp_config()
+    if not name:
+        raise RuntimeError("ClawPump MCP is not configured. Run `claw clawpump setup`.")
+
+    from tools.mcp_tool import (
+        _ensure_mcp_loop,
+        _run_on_mcp_loop,
+        _connect_server,
+        _stop_mcp_loop_if_idle,
+    )
+
+    _ensure_mcp_loop()
+    out = {"structured": None, "text": "", "error": None}
+
+    async def _call():
+        import asyncio as _asyncio
+
+        server = await _asyncio.wait_for(_connect_server(name, config), timeout=timeout)
+        try:
+            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):
+                out["error"] = text or "MCP tool returned an error"
+                return
+            out["text"] = text
+            sc = getattr(result, "structuredContent", None)
+            if isinstance(sc, dict) and sc:
+                out["structured"] = sc
+        finally:
+            await server.shutdown()
+
+    try:
+        _run_on_mcp_loop(_call(), timeout=timeout + 30)
+    finally:
+        try:
+            _stop_mcp_loop_if_idle()
+        except Exception:
+            pass
+
+    if out["error"]:
+        raise RuntimeError(out["error"])
+    # Both channels: structuredContent (machine; real secrets) AND the text
+    # (human; may redact secrets). Callers that need a secret check structured
+    # first, then fall back to the text — never drop one silently.
+    return {"structured": out["structured"], "text": out["text"]}
+
+
+def usepod_fetch_wallets():
+    """Return [{agent_id, name, usdc_balance}] for the user's ClawPump wallets.
+
+    Sorted by USDC balance (most-funded first) so the picker can default to it.
+    """
+    summaries = _channel_payload(_clawpump_tool_struct("get_wallet_summaries", {}, timeout=30))
+    if isinstance(summaries, dict):
+        summaries = summaries.get("wallets") or summaries.get("summaries") or []
+    rows = [w for w in (summaries or []) if isinstance(w, dict) and w.get("agent_id")]
+
+    # Enrich with display names (summaries carry only the agent_id UUID).
+    try:
+        agents = _channel_payload(_clawpump_tool_struct("list_agents", {}, timeout=30))
+        if isinstance(agents, dict):
+            agents = agents.get("agents") or []
+        names = {a.get("id"): a.get("name") for a in (agents or []) if isinstance(a, dict)}
+        for w in rows:
+            w["name"] = names.get(w.get("agent_id")) or w.get("name")
+    except Exception:
+        pass
+
+    rows.sort(key=lambda w: (w.get("usdc_balance") or 0), reverse=True)
+    return rows
+
+
+def _channel_payload(channels):
+    """Pick the usable object from a ``{structured, text}`` channel result:
+    structuredContent if present, else the parsed text JSON, else the raw."""
+    if not isinstance(channels, dict) or ("structured" not in channels and "text" not in channels):
+        return channels  # already a plain payload (back-compat)
+    sc = channels.get("structured")
+    if isinstance(sc, dict) and sc:
+        return sc
+    text = channels.get("text")
+    if isinstance(text, str) and text:
+        try:
+            import json as _json
+
+            return _json.loads(text)
+        except Exception:
+            return text
+    return None
+
+
+def usepod_provision_call(agent_id: str, amount: float) -> dict:
+    """Register + fund a Pod from ``agent_id``'s wallet. Spends on-chain USDC.
+
+    Returns the parsed result with the REAL api_token. The token lives in
+    ``structuredContent`` (the text channel redacts it), but we check BOTH —
+    structured first, then the text via the regex extractor — so a money-spent
+    provision never reports "no token" just because the channels were swapped.
+    """
+    channels = _clawpump_tool_struct(
+        "usepod_provision",
+        {"agent_id": agent_id, "amount": amount, "confirm_deposit": True},
+        timeout=120,
+    )
+    data = _channel_payload(channels)
+    if not isinstance(data, dict):
+        data = {}
+
+    def _real(tok: str) -> str:
+        # The redacted placeholder ("<applied… hidden>") is truthy but useless —
+        # treat it as no-token so we never persist it as a working credential.
+        tok = (tok or "").strip()
+        return "" if (not tok or tok.startswith("<") or "applied" in tok.lower()) else tok
+
+    # 1. structuredContent dict, 2. its nested wrappers, 3. the raw text regex.
+    api_token = _real(str(data.get("api_token") or data.get("token") or ""))
+    if not api_token:
+        tok = usepod_provision_token("mcp_clawpump_usepod_provision", data)
+        api_token = _real(tok[0] if tok else "")
+    if not api_token and isinstance(channels, dict):
+        tok = usepod_provision_token("mcp_clawpump_usepod_provision", channels.get("text") or "")
+        api_token = _real(tok[0] if tok else "")
+
+    return {
+        "api_token": api_token,
+        "deposit_code": str(data.get("deposit_code") or "").strip(),
+        "signature": str(data.get("signature") or ""),
+        "funding_error": str(data.get("funding_error") or ""),
+        "amount": data.get("amount"),
+    }

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