@agentlayer.tech/wallet 0.1.65 → 0.1.66

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Official OpenClaw plugin bridge for the agent-wallet backends, including Solana, local BTC, and local EVM.",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/VERSION

@@ -1 +1 @@
-0.1.65
+0.1.66

package/agent-wallet/agent_wallet/__init__.py

@@ -2,7 +2,7 @@
 
 # Keep in sync with package.json, pyproject.toml, and the npm installer version.
 # scripts/check_release_version.mjs enforces this on release.
-__version__ = "0.1.65"
+__version__ = "0.1.66"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -3928,6 +3928,9 @@ class OpenClawWalletAdapter:
                     raise WalletBackendError("text_body must be a string when provided.")
                 if not isinstance(purpose, str) or not purpose.strip():
                     raise WalletBackendError("purpose is required.")
+                approved_preview = args.get("_approved_preview")
+                if approved_preview is not None and not isinstance(approved_preview, dict):
+                    raise WalletBackendError("_approved_preview must be an object when provided.")
                 data = await x402.pay_and_fetch(
                     backend=active_backend,
                     url=url.strip(),
@@ -3936,6 +3939,7 @@ class OpenClawWalletAdapter:
                     query=query,
                     json_body=json_body,
                     text_body=text_body,
+                    approved_preview=approved_preview,
                 )
                 data["purpose"] = purpose.strip()
                 data = self._annotate_x402_payload(data, mode="execute")

package/agent-wallet/agent_wallet/providers/x402.py

@@ -6,6 +6,7 @@ import base64
 import hashlib
 import json
 import logging
+import time
 from typing import Any
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
@@ -17,6 +18,11 @@ from agent_wallet.wallet_layer.base import AgentWalletBackend
 CDP_BAZAAR_DISCOVERY_BASE_URL = "https://api.cdp.coinbase.com/platform/v2/x402/discovery"
 AGENTIC_MARKET_API_BASE_URL = "https://api.agentic.market/v1"
 X402_EXECUTE_TIMEOUT_SECONDS = 45.0
+DISCOVERY_CACHE_TTL_SECONDS = 300.0
+_DISCOVERY_CACHE_MAX_ENTRIES = 64
+# Discovery responses cached as JSON text so hits hand out independent copies.
+# Long-lived only inside the resident read worker; cold CLI runs start empty.
+_discovery_cache: dict[str, tuple[float, str]] = {}
 SOLANA_CAIP_BY_NETWORK = {
     "mainnet": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
 }
@@ -24,6 +30,12 @@ EVM_CAIP_BY_NETWORK = {
     "ethereum": "eip155:1",
     "base": "eip155:8453",
 }
+# x402 v1 requirements carry legacy network names instead of CAIP-2 ids.
+LEGACY_NETWORK_TO_CAIP = {
+    "ethereum": "eip155:1",
+    "base": "eip155:8453",
+    "solana": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+}
 _USDC_IDENTIFIERS = {
     "usdc",
     "usd coin",
@@ -200,6 +212,38 @@ def _decode_payment_required(header_value: str) -> dict[str, Any]:
     }
 
 
+def _caip_network(value: Any) -> str:
+    """Map a requirement network to CAIP-2 form, passing CAIP ids through."""
+    network = _trim(value)
+    if ":" in network:
+        return network
+    return LEGACY_NETWORK_TO_CAIP.get(network.lower(), network)
+
+
+def _decode_payment_required_body(response: Any) -> dict[str, Any] | None:
+    """Parse a legacy x402 v1 402 response whose requirements live in the JSON body.
+
+    Returns the same shape as _decode_payment_required, with `encoded` set to a
+    base64 form the x402 SDK can decode (it detects the version from the JSON).
+    """
+    try:
+        payload = response.json()
+    except Exception:
+        return None
+    if not isinstance(payload, dict) or payload.get("x402Version") != 1:
+        return None
+    accepts = payload.get("accepts")
+    if not isinstance(accepts, list) or not accepts:
+        return None
+    encoded = base64.b64encode(json.dumps(payload).encode("utf-8")).decode("ascii")
+    return {
+        "x402_version": 1,
+        "accepts": accepts,
+        "raw": payload,
+        "encoded": encoded,
+    }
+
+
 def _extract_requirement_extra(requirement: dict[str, Any]) -> dict[str, Any]:
     extra = requirement.get("extra")
     return dict(extra) if isinstance(extra, dict) else {}
@@ -210,12 +254,24 @@ def _requirement_field(requirement: Any, field_name: str) -> Any:
         aliases = {
             "pay_to": ("pay_to", "payTo"),
             "max_timeout_seconds": ("max_timeout_seconds", "maxTimeoutSeconds"),
+            "amount": ("amount", "maxAmountRequired"),
         }
         for candidate in aliases.get(field_name, (field_name,)):
             if candidate in requirement:
                 return requirement.get(candidate)
         return None
-    return getattr(requirement, field_name, None)
+    value = getattr(requirement, field_name, None)
+    if value is None and field_name == "amount":
+        # v1 SDK models expose the amount as max_amount_required / get_amount().
+        getter = getattr(requirement, "get_amount", None)
+        if callable(getter):
+            return getter()
+    return value
+
+
+def _requirement_amount(requirement: dict[str, Any]) -> str:
+    # x402 v2 uses "amount"; v1 uses "maxAmountRequired".
+    return _trim(requirement.get("amount") or requirement.get("maxAmountRequired"))
 
 
 def _looks_like_usdc(requirement: dict[str, Any]) -> bool:
@@ -227,7 +283,7 @@ def _looks_like_usdc(requirement: dict[str, Any]) -> bool:
 
 
 def _normalize_amount_hint(requirement: dict[str, Any]) -> str | None:
-    amount = _trim(requirement.get("amount"))
+    amount = _requirement_amount(requirement)
     if not amount.isdigit():
         return None
     if _looks_like_usdc(requirement):
@@ -247,7 +303,7 @@ def normalize_payment_requirement(
     resource_url: str | None = None,
 ) -> dict[str, Any]:
     extra = _extract_requirement_extra(requirement)
-    amount = _trim(requirement.get("amount"))
+    amount = _requirement_amount(requirement)
     return {
         "scheme": _trim(requirement.get("scheme")).lower() or None,
         "network": _trim(requirement.get("network")) or None,
@@ -405,7 +461,7 @@ def _wallet_x402_support_summary(backend: AgentWalletBackend) -> dict[str, Any]:
 
 def _requirement_compatibility(requirement: dict[str, Any], backend: AgentWalletBackend) -> dict[str, Any]:
     wallet_summary = _wallet_x402_support_summary(backend)
-    network = _trim(requirement.get("network"))
+    network = _caip_network(requirement.get("network"))
     scheme = _trim(requirement.get("scheme")).lower()
     wallet_network_matches = network in wallet_summary["supported_caip_networks"]
     chain = _backend_chain(backend)
@@ -458,23 +514,24 @@ def _select_preferred_requirement(
     requirements: list[dict[str, Any]],
     backend: AgentWalletBackend,
 ) -> dict[str, Any] | None:
-    compatible = [
-        requirement
-        for requirement in requirements
-        if _requirement_compatibility(requirement, backend)["planned_execution_supported"]
-    ]
-    exact_match = [
-        requirement
-        for requirement in compatible
-        if _requirement_compatibility(requirement, backend)["wallet_network_matches"]
-    ]
+    compatible: list[dict[str, Any]] = []
+    exact_match: list[dict[str, Any]] = []
+    for requirement in requirements:
+        compatibility = _requirement_compatibility(requirement, backend)
+        if not compatibility["planned_execution_supported"]:
+            continue
+        compatible.append(requirement)
+        if compatibility["wallet_network_matches"]:
+            exact_match.append(requirement)
     candidates = exact_match or compatible
     if not candidates:
         return None
 
-    def sort_key(item: dict[str, Any]) -> tuple[int, str]:
+    def sort_key(item: dict[str, Any]) -> tuple[int, int]:
         amount = _trim(item.get("amount"))
-        return (0 if amount.isdigit() else 1, amount)
+        if amount.isdigit():
+            return (0, int(amount))
+        return (1, 0)
 
     return sorted(candidates, key=sort_key)[0]
 
@@ -605,14 +662,16 @@ def _parse_payment_required_response(
     wallet_summary: dict[str, Any],
 ) -> dict[str, Any]:
     payment_required = response.headers.get("PAYMENT-REQUIRED")
-    if not payment_required:
-        raise ProviderError(
-            "x402-http",
-            "Server returned HTTP 402 without a PAYMENT-REQUIRED header.",
-            details={"status_code": response.status_code, "url": request["url"]},
-        )
-
-    decoded = _decode_payment_required(payment_required)
+    if payment_required:
+        decoded = _decode_payment_required(payment_required)
+    else:
+        decoded = _decode_payment_required_body(response)
+        if decoded is None:
+            raise ProviderError(
+                "x402-http",
+                "Server returned HTTP 402 without a PAYMENT-REQUIRED header or an x402 v1 JSON body.",
+                details={"status_code": response.status_code, "url": request["url"]},
+            )
     normalized_accepts = [
         normalize_payment_requirement(requirement, source="payment_required", resource_url=request["url"])
         for requirement in decoded["accepts"]
@@ -651,34 +710,6 @@ def _parse_payment_required_response(
     return preview
 
 
-def _require_executable_payment(
-    *,
-    preview: dict[str, Any],
-    backend: AgentWalletBackend,
-) -> dict[str, Any]:
-    selected = preview.get("selected_payment")
-    if not isinstance(selected, dict):
-        raise ProviderError(
-            "x402-http",
-            "No compatible x402 payment requirement was selected for this wallet.",
-            details={
-                "request_url": preview.get("request_url"),
-                "accepted_payments": preview.get("accepted_payments"),
-            },
-        )
-    compatibility = _requirement_compatibility(selected, backend)
-    if not compatibility["currently_executable"]:
-        raise ProviderError(
-            "x402-http",
-            str(compatibility["reason"]),
-            details={
-                "selected_payment": selected,
-                "compatibility": compatibility,
-            },
-        )
-    return selected
-
-
 def _validate_payment_requirement(
     selected: dict[str, Any] | None,
     *,
@@ -717,7 +748,7 @@ def _validate_payment_requirement(
 
     chain = _backend_chain(backend) or "unknown"
     network = _backend_network(backend) or "unknown"
-    requirement_network = _trim(selected.get("network")) or "unknown"
+    requirement_network = _caip_network(selected.get("network")) or "unknown"
     if chain == "solana" and requirement_network not in SOLANA_CAIP_BY_NETWORK.values():
         message = (
             f"This endpoint requires payment on {requirement_network}, but the active wallet is Solana ({network})."
@@ -1091,6 +1122,30 @@ def _log_x402_execute(
     )
 
 
+def _discovery_cache_get(cache_key: str) -> dict[str, Any] | None:
+    entry = _discovery_cache.get(cache_key)
+    if entry is None:
+        return None
+    expires_at, payload_text = entry
+    if expires_at <= time.monotonic():
+        _discovery_cache.pop(cache_key, None)
+        return None
+    return json.loads(payload_text)
+
+
+def _discovery_cache_set(cache_key: str, payload: dict[str, Any]) -> None:
+    try:
+        payload_text = json.dumps(payload)
+    except (TypeError, ValueError):
+        return
+    if len(_discovery_cache) >= _DISCOVERY_CACHE_MAX_ENTRIES:
+        for stale_key in sorted(_discovery_cache, key=lambda key: _discovery_cache[key][0])[
+            : len(_discovery_cache) - _DISCOVERY_CACHE_MAX_ENTRIES + 1
+        ]:
+            _discovery_cache.pop(stale_key, None)
+    _discovery_cache[cache_key] = (time.monotonic() + DISCOVERY_CACHE_TTL_SECONDS, payload_text)
+
+
 async def search_services(
     *,
     query: str | None = None,
@@ -1106,20 +1161,62 @@ async def search_services(
         provider = "cdp_bazaar"
     if limit <= 0:
         raise ProviderError("x402-discovery", "limit must be greater than zero.")
+    cache_key = _canonical_json_text(
+        {
+            "op": "search_services",
+            "provider": provider,
+            "query": _trim(query),
+            "network": _trim(network),
+            "asset": _trim(asset),
+            "scheme": _trim(scheme),
+            "max_usd_price": _trim(max_usd_price),
+            "limit": limit,
+        }
+    )
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
+    result = await _search_services_uncached(
+        query=query,
+        provider=provider,
+        network=network,
+        asset=asset,
+        scheme=scheme,
+        max_usd_price=max_usd_price,
+        limit=limit,
+    )
+    _discovery_cache_set(cache_key, result)
+    return result
+
+
+async def _search_services_uncached(
+    *,
+    query: str | None,
+    provider: str,
+    network: str | None,
+    asset: str | None,
+    scheme: str | None,
+    max_usd_price: str | None,
+    limit: int,
+) -> dict[str, Any]:
     client = get_client()
 
     if provider == "cdp_bazaar":
         if query and _trim(query):
+            # CDP rejects empty filter values with HTTP 400, so omit unset params
+            # entirely instead of sending them as blank strings.
+            search_params: dict[str, Any] = {"query": _trim(query), "limit": min(limit, 20)}
+            for name, value in (
+                ("network", network),
+                ("asset", asset),
+                ("scheme", scheme),
+                ("maxUsdPrice", max_usd_price),
+            ):
+                if _trim(value):
+                    search_params[name] = _trim(value)
             response = await client.get(
                 f"{CDP_BAZAAR_DISCOVERY_BASE_URL}/search",
-                params={
-                    "query": _trim(query),
-                    "network": _trim(network) or None,
-                    "asset": _trim(asset) or None,
-                    "scheme": _trim(scheme) or None,
-                    "maxUsdPrice": _trim(max_usd_price) or None,
-                    "limit": min(limit, 20),
-                },
+                params=search_params,
             )
             payload = _parse_json_response(
                 response, provider="x402-cdp-bazaar", operation="CDP Bazaar search"
@@ -1214,19 +1311,40 @@ async def get_service_details(
         )
 
     if provider == "cdp_bazaar":
-        resources = await search_services(discovery_provider="cdp_bazaar", limit=200)
-        exact = next((item for item in resources["items"] if item.get("resource") == ref), None)
-        if exact is None:
+
+        def _match(items: list[dict[str, Any]]) -> dict[str, Any] | None:
+            exact = next((item for item in items if item.get("resource") == ref), None)
+            if exact is not None:
+                return exact
             needle = ref.lower()
-            exact = next(
+            return next(
                 (
                     item
-                    for item in resources["items"]
+                    for item in items
                     if needle in _trim(item.get("resource")).lower()
                     or needle in _trim(item.get("description")).lower()
                 ),
                 None,
             )
+
+        # Server-side search covers the full Bazaar catalog; a plain resource
+        # listing only ever returns the first page, so use it as a last resort.
+        queries = [ref]
+        if ref.startswith(("http://", "https://")):
+            netloc = _trim(urlsplit(ref).netloc)
+            if netloc and netloc != ref:
+                queries.append(netloc)
+        exact: dict[str, Any] | None = None
+        for candidate_query in queries:
+            results = await search_services(
+                query=candidate_query, discovery_provider="cdp_bazaar", limit=20
+            )
+            exact = _match(results["items"])
+            if exact is not None:
+                break
+        if exact is None:
+            resources = await search_services(discovery_provider="cdp_bazaar", limit=200)
+            exact = _match(resources["items"])
         if exact is None:
             raise ProviderError("x402-cdp-bazaar", f"No Bazaar resource matched: {ref}")
         return {"discovery_provider": provider, "service": exact}
@@ -1330,78 +1448,30 @@ async def preview_request(
     return payment_preview
 
 
-async def prepare_request(
+def _reusable_approved_preview(
+    approved_preview: Any,
     *,
-    backend: AgentWalletBackend,
-    url: str,
-    method: str = "GET",
-    headers: dict[str, Any] | None = None,
-    query: dict[str, Any] | None = None,
-    json_body: Any | None = None,
-    text_body: str | None = None,
-) -> dict[str, Any]:
-    preview = await preview_request(
-        backend=backend,
-        url=url,
-        method=method,
-        headers=headers,
-        query=query,
-        json_body=json_body,
-        text_body=text_body,
-    )
-    if not preview.get("payment_required"):
-        prepared = dict(preview)
-        prepared["mode"] = "prepare"
-        prepared["prepared"] = False
-        prepared["prepare_note"] = "The endpoint did not require x402 payment for this request."
-        return prepared
-
-    selected_payment = _require_executable_payment(preview=preview, backend=backend)
-    payment_required_header = (
-        dict(preview.get("response_headers") or {}).get("payment-required")
-    )
-    if not isinstance(payment_required_header, str) or not payment_required_header.strip():
-        raise ProviderError("x402-http", "Missing PAYMENT-REQUIRED header in preview state.")
-    # Create the payload once during prepare to validate that the active wallet can sign it.
-    await _create_payment_headers(
-        backend=backend,
-        payment_required_header=payment_required_header,
-        selected_payment=selected_payment,
-    )
-    prepared = dict(preview)
-    prepared["mode"] = "prepare"
-    prepared["prepared"] = True
-    prepared["signed"] = False
-    prepared["broadcasted"] = False
-    prepared["confirmed"] = False
-    prepared["payment_payload_withheld"] = True
-    prepared["prepare_note"] = (
-        "x402 payment authorization was validated locally, but the PAYMENT-SIGNATURE header is withheld until execute."
-    )
-    return prepared
-
-
-async def execute_request(
-    *,
-    backend: AgentWalletBackend,
-    url: str,
-    method: str = "GET",
-    headers: dict[str, Any] | None = None,
-    query: dict[str, Any] | None = None,
-    json_body: Any | None = None,
-    text_body: str | None = None,
-) -> dict[str, Any]:
-    executed = await pay_and_fetch(
-        backend=backend,
-        url=url,
-        method=method,
-        headers=headers,
-        query=query,
-        json_body=json_body,
-        text_body=text_body,
-    )
-    executed["mode"] = "execute"
-    return executed
+    request: dict[str, Any],
+) -> dict[str, Any] | None:
+    """Return an approval-time preview usable instead of a fresh unpaid probe.
+
+    Reuse is only safe when the preview describes exactly this request
+    (fingerprint covers method, final URL, and body hash) and still carries the
+    encoded PAYMENT-REQUIRED challenge plus a selected payment. Anything else
+    falls back to a fresh probe.
+    """
+    if not isinstance(approved_preview, dict):
+        return None
+    if not approved_preview.get("payment_required"):
+        return None
+    if _trim(approved_preview.get("request_fingerprint")) != request["request_fingerprint"]:
+        return None
+    if not isinstance(approved_preview.get("selected_payment"), dict):
+        return None
+    header = dict(approved_preview.get("response_headers") or {}).get("payment-required")
+    if not isinstance(header, str) or not header.strip():
+        return None
+    return dict(approved_preview)
 
 
 async def pay_and_fetch(
@@ -1413,9 +1483,9 @@ async def pay_and_fetch(
     query: dict[str, Any] | None = None,
     json_body: Any | None = None,
     text_body: str | None = None,
+    approved_preview: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
-    preview = await preview_request(
-        backend=backend,
+    request = _build_request_metadata(
         url=url,
         method=method,
         headers=headers,
@@ -1423,6 +1493,18 @@ async def pay_and_fetch(
         json_body=json_body,
         text_body=text_body,
     )
+    preview = _reusable_approved_preview(approved_preview, request=request)
+    reused_approved_preview = preview is not None
+    if preview is None:
+        preview = await preview_request(
+            backend=backend,
+            url=url,
+            method=method,
+            headers=headers,
+            query=query,
+            json_body=json_body,
+            text_body=text_body,
+        )
     if not preview.get("payment_required"):
         executed = dict(preview)
         executed["mode"] = "execute"
@@ -1444,14 +1526,6 @@ async def pay_and_fetch(
     if not isinstance(payment_required_header, str) or not payment_required_header.strip():
         raise ProviderError("x402-http", "Missing PAYMENT-REQUIRED header in preview state.")
 
-    request = _build_request_metadata(
-        url=url,
-        method=method,
-        headers=headers,
-        query=query,
-        json_body=json_body,
-        text_body=text_body,
-    )
     _validate_request_execution_policy(request=request, backend=backend)
     payment_headers = await _create_payment_headers(
         backend=backend,
@@ -1478,6 +1552,7 @@ async def pay_and_fetch(
         {
             "mode": "execute",
             "paid": True,
+            "reused_approved_preview": reused_approved_preview,
             "broadcasted": bool(settlement and settlement.get("transaction")),
             "confirmed": bool(settlement and settlement.get("success")),
             "payment_settlement": settlement,
@@ -1491,9 +1566,15 @@ async def pay_and_fetch(
         }
     )
     if response.status_code == 402:
+        message = "The paid x402 retry still returned HTTP 402."
+        if reused_approved_preview:
+            message += (
+                " The payment was signed from the approved preview quote; the server may have"
+                " re-priced the endpoint since then. Run x402_preview_request again and retry."
+            )
         raise ProviderError(
             "x402-http",
-            "The paid x402 retry still returned HTTP 402.",
+            message,
             details={
                 "request_url": request["url"],
                 "selected_payment": selected_payment,

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.65"
+version = "0.1.66"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/agent-wallet/skills/wallet-operator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: wallet-operator
-description: Use when operating OpenClaw wallet tools: balances, transfers, swaps, LI.FI cross-chain swaps, Jupiter swaps, Velora EVM swaps, BTC transfers, staking, Kamino lending, Bags launches, and wallet execution safety.
+description: Use whenever the user's own funds are involved, even if they never say "wallet": balances, portfolio, transfers, swaps, LI.FI cross-chain swaps, Jupiter swaps, Velora EVM swaps, BTC transfers, staking, Kamino lending, Bags launches, and wallet execution safety.
 ---
 
 # Wallet Operator

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/claude-code/plugins/agent-wallet/skills/wallet-operator/SKILL.md

@@ -1,5 +1,5 @@
 ---
-description: "Use when the user asks Claude Code to interact with the local AgentLayer wallet runtime: check balances, transfer tokens, swap, DeFi operations, or x402 payments. Prefer wallet tools over shell commands. Preview writes first and execute only after explicit user confirmation."
+description: "Use whenever the user's own funds or wallet are involved — balances, portfolio, transfers, swaps, bridging, staking, lending, or x402 payments — even if the user never says \"wallet\". Trigger phrases include \"my balance\", \"how much SOL/ETH/BTC/USDC do I have\", \"send/transfer X to\", \"swap\", \"bridge\", \"stake\", \"my portfolio\", \"pay for this API\", \"x402\". Prefer agent-wallet MCP tools over shell commands, raw RPC, or crypto data servers. Preview writes first and execute only after explicit user confirmation."
 ---
 
 # Agent Wallet Operator

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/server.py

@@ -273,6 +273,44 @@ def _cache_preview_for_approval(user_id: str, tool_name: str, payload: dict[str,
         }
 
 
+X402_PREVIEW_REUSE_TTL_SECONDS = 300
+
+
+def _cache_x402_preview_payload(user_id: str, payload: dict[str, Any]) -> None:
+    """Cache a paid-endpoint preview so x402_pay_request can skip its unpaid probe.
+
+    x402 previews run on the read-only resident-worker path, so they never reach
+    _cache_preview_for_approval (and preview-mode annotation strips
+    confirmation_summary anyway). Stored under the x402_preview_request key that
+    the pay alias resolves to. The wallet runtime revalidates the payload by
+    request fingerprint and falls back to a fresh probe on any mismatch, so a
+    stale or unrelated cached preview can never redirect a payment.
+    """
+    if not isinstance(payload, dict) or payload.get("ok") is False:
+        return
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        return
+    if not data.get("payment_required") or not str(data.get("request_fingerprint") or "").strip():
+        return
+    with _approval_cache_lock:
+        _prune_approval_preview_cache()
+        approval_preview_cache[_approval_cache_key(user_id, "x402_preview_request")] = {
+            "digest": _preview_digest(data),
+            "expires_at": time.time() + X402_PREVIEW_REUSE_TTL_SECONDS,
+            "preview": data,
+            "summary": None,
+        }
+
+
+def _attach_x402_approved_preview(tool_name: str, effective_params: dict[str, Any]) -> None:
+    if tool_name != "x402_pay_request" or "_approved_preview" in effective_params:
+        return
+    cached = _latest_cached_preview(_user_id(), tool_name)
+    if cached and isinstance(cached.get("preview"), dict):
+        effective_params["_approved_preview"] = cached["preview"]
+
+
 def _latest_cached_preview(user_id: str, tool_name: str) -> dict[str, Any] | None:
     with _approval_cache_lock:
         _prune_approval_preview_cache()
@@ -1403,6 +1441,7 @@ def _invoke_wallet_tool_blocking(
     cancellation stay responsive).
     """
     used_cache, approval_args = _attach_approval_for_execute(tool_name, config, effective_params)
+    _attach_x402_approved_preview(tool_name, effective_params)
     try:
         payload = _invoke_tool(
             tool_name,
@@ -1413,6 +1452,10 @@ def _invoke_wallet_tool_blocking(
         )
     except Exception as exc:
         raise _normalize_approval_context_error(exc) from exc
+    if tool_name == "x402_pay_request":
+        # The cached x402 preview quote is single-use: whether the payment
+        # succeeded or the endpoint re-priced, the next pay must re-preview.
+        _consume_cached_preview(_user_id(), tool_name)
     _cache_preview_for_approval(_user_id(), tool_name, payload)
     # A bridge-managed preview that was just executed successfully is single-use:
     # drop it so a duplicate execute cannot silently re-run the operation.
@@ -1451,15 +1494,21 @@ async def _handle_wallet_tool(tool_name: str, params: dict[str, Any]) -> dict[st
             _invoke_wallet_tool_blocking, tool_name, config, effective_params
         )
 
+    if tool_name == "x402_preview_request":
+        _cache_x402_preview_payload(_user_id(), payload)
     if payload.get("ok") is False:
         raise RuntimeError(str(payload.get("error") or f"{tool_name} failed"))
     return payload.get("data", {})
 
 
 BASE_INSTRUCTIONS = (
-    "Use the local AgentLayer wallet runtime through explicit wallet tools. Keep wallet "
-    "secrets local. Preview writes first when supported, and execute only after explicit "
-    "user confirmation."
+    "This server is the user's own local AgentLayer wallet (Solana, EVM, Bitcoin). Use its "
+    "tools whenever the user asks about their balances, portfolio, addresses, transfers, "
+    "swaps, bridging, staking, lending, or x402 payments — even when they never say the "
+    "word 'wallet'. For anything touching the user's own funds, prefer these tools over "
+    "shell commands, raw RPC calls, or other crypto data servers (those are for arbitrary "
+    "addresses and market data, not the user's wallet). Keep wallet secrets local. Preview "
+    "writes first when supported, and execute only after explicit user confirmation."
 )
 
 

package/codex/plugins/agent-wallet/skills/wallet-operator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: "wallet-operator"
-description: "Use when the user asks Codex to interact with the local AgentLayer wallet runtime. Prefer wallet tools over shell commands, preview writes first, and keep approval/signing semantics intact."
+description: "Use whenever the user's own funds or wallet are involved — balances, portfolio, transfers, swaps, bridging, staking, lending, or x402 payments — even if the user never says \"wallet\". Trigger phrases include \"my balance\", \"how much SOL/ETH/BTC/USDC do I have\", \"send/transfer X to\", \"swap\", \"bridge\", \"stake\", \"my portfolio\". Prefer wallet tools over shell commands, preview writes first, and keep approval/signing semantics intact."
 ---
 
 # Agent Wallet Operator

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.65
+version: 0.1.66
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/install-from-github.sh

@@ -120,9 +120,15 @@ if [ -z "$SOURCE_ROOT" ] || [ ! -d "$SOURCE_ROOT" ]; then
   exit 1
 fi
 
+# Pre-flight must be a superset of setup.sh's require_path list: everything is
+# checked on the EXTRACTED temp tree, before the destructive swap below. A
+# bundle that would fail setup.sh must never replace the user's runtime.
 require_path "$SOURCE_ROOT/setup.sh" "local setup entrypoint"
 require_path "$SOURCE_ROOT/agent-wallet" "agent-wallet package"
+require_path "$SOURCE_ROOT/agent-wallet/scripts/install_agent_wallet.py" "Python installer"
 require_path "$SOURCE_ROOT/.openclaw/extensions/agent-wallet" "OpenClaw extension"
+require_path "$SOURCE_ROOT/codex/plugins/agent-wallet/.codex-plugin/plugin.json" "Codex plugin"
+require_path "$SOURCE_ROOT/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json" "Claude Code plugin"
 require_path "$SOURCE_ROOT/wdk-btc-wallet/package.json" "wdk-btc-wallet runtime"
 require_path "$SOURCE_ROOT/wdk-evm-wallet/package.json" "wdk-evm-wallet runtime"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",