@agentlayer.tech/wallet 0.1.88 → 0.1.90

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -281,6 +281,10 @@ class OpenClawWalletAdapter:
                         "json_body": {},
                         "text_body": {"type": "string"},
                         "purpose": {"type": "string"},
+                        "approval_token": {
+                            "type": "string",
+                            "description": "Host-issued approval token required for execute mode when the payment is mainnet/real-value and no autonomous session or permission grant covers it.",
+                        },
                     },
                     "required": ["url", "purpose"],
                     "additionalProperties": False,
@@ -493,10 +497,25 @@ class OpenClawWalletAdapter:
                     )
                 )
             else:
-                raise WalletBackendError(
-                    f"{action_label} execution requires a host-issued approval_token "
-                    "(or an active autonomous session authorized by the host)."
-                )
+                # No budgeted session either: fall back to the standing
+                # high-trust permission toggle (agentlayer_autonomous_approve).
+                # This is the single choke point every execute tool funnels
+                # through, so enabling that toggle covers every tool here --
+                # not just the Base-swap/EVM-DeFi tools that also have their
+                # own dedicated pre-authorization step before reaching here.
+                from agent_wallet import autonomous_permissions
+
+                if autonomous_permissions.is_autonomous_approved():
+                    approval_token = autonomous_permissions.authorize_operation(
+                        tool_name=tool_name,
+                        network=network,
+                        summary=summary,
+                    )
+                else:
+                    raise WalletBackendError(
+                        f"{action_label} execution requires a host-issued approval_token "
+                        "(or an active autonomous session/permission grant authorized by the host)."
+                    )
         verify_approval_token(
             approval_token.strip(),
             tool_name=tool_name,
@@ -1147,19 +1166,29 @@ class OpenClawWalletAdapter:
             annotated["payment_summary"] = summary
         requirements = dict(annotated.get("confirmation_requirements") or {})
         requirements["prepare_requires_user_intent"] = False
-        requirements["execute_requires_approval_token"] = False
-        requirements["execute_requires_mainnet_confirmed_in_token"] = False
+        de_minimis = x402.is_de_minimis_payment(payload)
+        if de_minimis:
+            # Below x402.DE_MINIMIS_USD_THRESHOLD, this payment never needs
+            # approval -- not even on mainnet -- so keep the advertised
+            # requirement honest in both preview and execute responses.
+            requirements["execute_requires_approval_token"] = False
+            requirements["execute_requires_mainnet_confirmed_in_token"] = False
+            annotated["de_minimis_payment"] = {
+                "applied": True,
+                "threshold_usd": x402.DE_MINIMIS_USD_THRESHOLD,
+                "amount_usd": x402.de_minimis_usd_amount(payload),
+            }
         annotated.pop("approval_hint", None)
         if mode == "preview":
             annotated.pop("confirmation_summary", None)
-            annotated.pop("confirmation_requirements", None)
-            if annotated.get("is_mainnet"):
+            annotated["confirmation_requirements"] = requirements
+            if annotated.get("is_mainnet") and not de_minimis:
                 annotated["preview_note"] = (
                     "This is a paid mainnet endpoint preview only. Review the service URL, network, asset, amount, and payment destination before calling x402_pay_request."
                 )
             return annotated
         annotated["confirmation_requirements"] = requirements
-        if annotated.get("is_mainnet"):
+        if annotated.get("is_mainnet") and not de_minimis:
             annotated["mainnet_warning"] = (
                 "Mainnet x402 payment. Confirm the service URL, network, asset, amount, and payment destination before paying."
             )
@@ -2211,6 +2240,67 @@ class OpenClawWalletAdapter:
                         risk_level="low",
                     ),
                 )
+                tools.append(
+                    AgentToolSpec(
+                        name="search_uniswap_pairs",
+                        description=(
+                            "Search for onchain Uniswap-tradeable token pairs by ticker/name or by exact "
+                            "ERC-20 address, with live price, 5m/1h/6h/24h volume, liquidity, FDV, market "
+                            "cap, and buy/sell counts. Backed by DexScreener's public index (covers "
+                            "Uniswap v2/v3/v4 pools and other DEXes on the same chain), since the Uniswap "
+                            "Trading API itself only quotes a pair you already know the addresses for, not "
+                            "search-by-name. Defaults to the currently active EVM network (e.g. robinhood); "
+                            "set all_chains to search across every chain DexScreener indexes. Read-only "
+                            "market data, not a swap quote. Free-text search can surface impersonator "
+                            "tokens reusing a legitimate ticker with fabricated liquidity/FDV — before "
+                            "quoting or swapping, verify the token_address independently (e.g. via "
+                            "get_evm_token_metadata) rather than trusting the top result by symbol match. "
+                            "Do not use liquidity/FDV size to pick a winner: observed impersonators on "
+                            "robinhood fabricate liquidity/FDV an order of magnitude above the genuine "
+                            "pool specifically to look most trustworthy, and a Uniswap quote succeeding "
+                            "for a token proves nothing either (Trading API routes any pool with reserves, "
+                            "impersonators included). This only matters for tickers claiming to represent "
+                            "a real-world asset (stocks/ETFs) - unrelated meme/community tokens on the "
+                            "same chain aren't impersonators just for lacking a canonical issuer. When the "
+                            "query is a real-world-asset ticker, cross-check the returned token_address "
+                            "against Robinhood's own canonical list at docs.robinhood.com/chain/contracts "
+                            "(or the equivalent official source for other chains) before relying on the result."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "Free-text search, e.g. a ticker or name (\"AAPL\", \"Apple Robinhood\"). Required unless token_address is given.",
+                                },
+                                "token_address": {
+                                    "type": "string",
+                                    "description": "Exact ERC-20 contract address to look up instead of a free-text query.",
+                                },
+                                "chain": {
+                                    "type": "string",
+                                    "description": "DexScreener chain slug to filter to (e.g. \"robinhood\", \"ethereum\", \"base\"). Defaults to the active EVM network.",
+                                },
+                                "dex_id": {
+                                    "type": "string",
+                                    "description": "Optional exact DEX filter, e.g. \"uniswap\".",
+                                },
+                                "all_chains": {
+                                    "type": "boolean",
+                                    "description": "If true, do not filter query results to a single chain. Ignored when token_address is set.",
+                                },
+                                "limit": {
+                                    "type": "integer",
+                                    "description": "Max number of pairs to return (1-30). Defaults to 10.",
+                                },
+                            },
+                            "required": [],
+                            "additionalProperties": False,
+                        },
+                        read_only=True,
+                        risk_level="low",
+                    ),
+                )
                 tools.insert(
                     12,
                     AgentToolSpec(
@@ -3806,7 +3896,9 @@ class OpenClawWalletAdapter:
                 name="agentlayer_autonomous_status",
                 description=(
                     "Return AgentLayer high-trust autonomous permission status. "
-                    "The autonomous permission group contains base_swaps and defi_tools."
+                    "The autonomous permission group covers every wallet write tool (transfers, "
+                    "bridges, Solana swaps, staking, x402 payments, generic contract calls, Base "
+                    "swaps, and EVM DeFi management), not just base_swaps/defi_tools."
                 ),
                 input_schema={
                     "type": "object",
@@ -3822,17 +3914,18 @@ class OpenClawWalletAdapter:
                 name="agentlayer_autonomous_approve",
                 description=(
                     "Enable the high-trust autonomous permission group. The scope parameter is kept "
-                    "for compatibility; choosing base_swaps or defi_tools enables both Base swaps and "
-                    "supported EVM DeFi management tools until revoked. This does not cover transfers, "
-                    "bridges, Solana swaps, or generic contract calls."
+                    "for compatibility; choosing base_swaps or defi_tools enables the full group, "
+                    "which covers every wallet write tool -- transfers, bridges, Solana swaps, "
+                    "staking, x402 payments, generic contract calls, Base swaps, and supported EVM "
+                    "DeFi management tools -- until revoked."
                 ),
                 input_schema={
                     "type": "object",
                     "properties": {
                         "scope": {
                             "type": "string",
-                            "enum": ["base_swaps", "defi_tools"],
-                            "description": "Compatibility scope; either value enables the full autonomous permission group.",
+                            "enum": ["all", "base_swaps", "defi_tools"],
+                            "description": "Scope to enable. Use \"all\" (recommended) -- base_swaps and defi_tools are deprecated aliases that enable the exact same full autonomous permission group, covering every wallet write tool.",
                         },
                         "purpose": {
                             "type": "string",
@@ -3862,8 +3955,8 @@ class OpenClawWalletAdapter:
                     "properties": {
                         "scope": {
                             "type": "string",
-                            "enum": ["base_swaps", "defi_tools"],
-                            "description": "Compatibility scope; either value revokes the full autonomous permission group.",
+                            "enum": ["all", "base_swaps", "defi_tools"],
+                            "description": "Scope to revoke. Use \"all\" (recommended) -- base_swaps and defi_tools are deprecated aliases that revoke the exact same full autonomous permission group.",
                         }
                     },
                     "required": ["scope"],
@@ -3888,7 +3981,9 @@ class OpenClawWalletAdapter:
                 name="agentlayer_autonomous_status",
                 description=(
                     "Return AgentLayer high-trust autonomous permission status. "
-                    "The autonomous permission group contains base_swaps and defi_tools."
+                    "The autonomous permission group covers every wallet write tool (transfers, "
+                    "bridges, Solana swaps, staking, x402 payments, generic contract calls, Base "
+                    "swaps, and EVM DeFi management), not just base_swaps/defi_tools."
                 ),
                 input_schema={
                     "type": "object",
@@ -3902,17 +3997,18 @@ class OpenClawWalletAdapter:
                 name="agentlayer_autonomous_approve",
                 description=(
                     "Enable the high-trust autonomous permission group. The scope parameter is kept "
-                    "for compatibility; choosing base_swaps or defi_tools enables both Base swaps and "
-                    "supported EVM DeFi management tools until revoked. This does not cover transfers, "
-                    "bridges, Solana swaps, or generic contract calls."
+                    "for compatibility; choosing base_swaps or defi_tools enables the full group, "
+                    "which covers every wallet write tool -- transfers, bridges, Solana swaps, "
+                    "staking, x402 payments, generic contract calls, Base swaps, and supported EVM "
+                    "DeFi management tools -- until revoked."
                 ),
                 input_schema={
                     "type": "object",
                     "properties": {
                         "scope": {
                             "type": "string",
-                            "enum": ["base_swaps", "defi_tools"],
-                            "description": "Compatibility scope; either value enables the full autonomous permission group.",
+                            "enum": ["all", "base_swaps", "defi_tools"],
+                            "description": "Scope to enable. Use \"all\" (recommended) -- base_swaps and defi_tools are deprecated aliases that enable the exact same full autonomous permission group, covering every wallet write tool.",
                         },
                         "purpose": {
                             "type": "string",
@@ -3940,8 +4036,8 @@ class OpenClawWalletAdapter:
                     "properties": {
                         "scope": {
                             "type": "string",
-                            "enum": ["base_swaps", "defi_tools"],
-                            "description": "Compatibility scope; either value revokes the full autonomous permission group.",
+                            "enum": ["all", "base_swaps", "defi_tools"],
+                            "description": "Scope to revoke. Use \"all\" (recommended) -- base_swaps and defi_tools are deprecated aliases that revoke the exact same full autonomous permission group.",
                         }
                     },
                     "required": ["scope"],
@@ -3979,7 +4075,7 @@ class OpenClawWalletAdapter:
                 scope = str(args.get("scope") or "").strip()
                 purpose = args.get("purpose")
                 if scope not in autonomous_permissions.SUPPORTED_SCOPES:
-                    raise WalletBackendError("scope must be one of: base_swaps, defi_tools.")
+                    raise WalletBackendError("scope must be one of: all, base_swaps, defi_tools.")
                 if not isinstance(purpose, str) or not purpose.strip():
                     raise WalletBackendError("purpose is required.")
                 if args.get("user_intent") is not True:
@@ -4000,7 +4096,7 @@ class OpenClawWalletAdapter:
 
                 scope = str(args.get("scope") or "").strip()
                 if scope not in autonomous_permissions.SUPPORTED_SCOPES:
-                    raise WalletBackendError("scope must be one of: base_swaps, defi_tools.")
+                    raise WalletBackendError("scope must be one of: all, base_swaps, defi_tools.")
                 return AgentToolResult(
                     tool=tool_name,
                     ok=True,
@@ -4145,7 +4241,14 @@ class OpenClawWalletAdapter:
                 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(
+                approval_token = args.get("approval_token")
+
+                # Resolve the exact payment about to be made -- reusing
+                # _approved_preview when it still matches this request (same
+                # fingerprint check pay_and_fetch applies internally), or a
+                # fresh probe otherwise -- so the summary bound into the
+                # approval token below is never stale or re-priced.
+                preview_payload = await x402.resolve_payment_preview(
                     backend=active_backend,
                     url=url.strip(),
                     method=method,
@@ -4155,6 +4258,32 @@ class OpenClawWalletAdapter:
                     text_body=text_body,
                     approved_preview=approved_preview,
                 )
+                de_minimis = False
+                if preview_payload.get("payment_required"):
+                    de_minimis = x402.is_de_minimis_payment(preview_payload)
+                    if not de_minimis:
+                        summary = self._build_confirmation_summary(
+                            action_label="x402 paid request",
+                            payload=preview_payload,
+                        )
+                        self._require_execute_approval(
+                            approval_token=approval_token,
+                            tool_name=tool_name,
+                            summary=summary,
+                            action_label="x402 paid request",
+                            backend=active_backend,
+                        )
+
+                data = await x402.pay_and_fetch(
+                    backend=active_backend,
+                    url=url.strip(),
+                    method=method,
+                    headers=headers,
+                    query=query,
+                    json_body=json_body,
+                    text_body=text_body,
+                    approved_preview=preview_payload,
+                )
                 data["purpose"] = purpose.strip()
                 data = self._annotate_x402_payload(data, mode="execute")
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
@@ -5349,57 +5478,68 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(active_backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(active_backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
                     )
-                source_chain_id = self._canonicalize_lifi_chain_identifier(
-                    getattr(active_backend, "network", "unknown")
-                )
-                destination_chain_id = self._canonicalize_lifi_chain_identifier(destination_chain)
-                expected_summary = {
-                    "operation": "EVM LI.FI cross-chain swap",
-                    "network": str(getattr(active_backend, "network", "unknown")),
-                    "source_chain": source_chain_id,
-                    "destination_chain": destination_chain_id,
-                    "token_in": self._canonicalize_lifi_token_identifier(
-                        token_in,
-                        chain_id=source_chain_id,
-                    ),
-                    "output_token": self._canonicalize_lifi_token_identifier(
-                        output_token,
-                        chain_id=destination_chain_id,
-                    ),
-                    "destination_address": destination_address.strip(),
-                    "input_amount_raw": amount_in_raw.strip(),
-                }
-                for key, expected_value in expected_summary.items():
-                    actual_value = approval_summary.get(key)
-                    if key in {"source_chain", "destination_chain"}:
-                        actual_value = self._canonicalize_lifi_chain_identifier(actual_value)
-                    if key == "token_in":
-                        actual_value = self._canonicalize_lifi_token_identifier(
-                            actual_value,
-                            chain_id=source_chain_id,
-                        )
-                    if key == "output_token":
-                        actual_value = self._canonicalize_lifi_token_identifier(
-                            actual_value,
-                            chain_id=destination_chain_id,
-                        )
-                    if actual_value != expected_value:
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
                             "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
+                    source_chain_id = self._canonicalize_lifi_chain_identifier(
+                        getattr(active_backend, "network", "unknown")
+                    )
+                    destination_chain_id = self._canonicalize_lifi_chain_identifier(destination_chain)
+                    expected_summary = {
+                        "operation": "EVM LI.FI cross-chain swap",
+                        "network": str(getattr(active_backend, "network", "unknown")),
+                        "source_chain": source_chain_id,
+                        "destination_chain": destination_chain_id,
+                        "token_in": self._canonicalize_lifi_token_identifier(
+                            token_in,
+                            chain_id=source_chain_id,
+                        ),
+                        "output_token": self._canonicalize_lifi_token_identifier(
+                            output_token,
+                            chain_id=destination_chain_id,
+                        ),
+                        "destination_address": destination_address.strip(),
+                        "input_amount_raw": amount_in_raw.strip(),
+                    }
+                    for key, expected_value in expected_summary.items():
+                        actual_value = approval_summary.get(key)
+                        if key in {"source_chain", "destination_chain"}:
+                            actual_value = self._canonicalize_lifi_chain_identifier(actual_value)
+                        if key == "token_in":
+                            actual_value = self._canonicalize_lifi_token_identifier(
+                                actual_value,
+                                chain_id=source_chain_id,
+                            )
+                        if key == "output_token":
+                            actual_value = self._canonicalize_lifi_token_identifier(
+                                actual_value,
+                                chain_id=destination_chain_id,
+                            )
+                        if actual_value != expected_value:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                            )
 
-                approval_summary_copy = dict(approval_summary)
+                    approval_summary_copy = dict(approval_summary)
+                else:
+                    # No host token: build the exact preview a human would
+                    # have seen and let _require_execute_approval's
+                    # autonomous_session / agentlayer_autonomous_approve
+                    # fallback authorize it.
+                    fresh_preview = await active_backend.preview_evm_lifi_cross_chain_swap(**preview_kwargs)
+                    approval_summary_copy = self._build_confirmation_summary(
+                        action_label="EVM LI.FI cross-chain swap",
+                        payload=fresh_preview,
+                    )
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
@@ -5460,6 +5600,37 @@ class OpenClawWalletAdapter:
                 )
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
+            if tool_name == "search_uniswap_pairs":
+                query = args.get("query")
+                token_address = args.get("token_address")
+                chain = args.get("chain")
+                dex_id = args.get("dex_id")
+                all_chains = bool(args.get("all_chains", False))
+                limit = args.get("limit", 10)
+                if query is not None and not isinstance(query, str):
+                    raise WalletBackendError("query must be a string.")
+                if token_address is not None and not isinstance(token_address, str):
+                    raise WalletBackendError("token_address must be a string.")
+                if not (isinstance(query, str) and query.strip()) and not (
+                    isinstance(token_address, str) and token_address.strip()
+                ):
+                    raise WalletBackendError("Either query or token_address is required.")
+                if chain is not None and not isinstance(chain, str):
+                    raise WalletBackendError("chain must be a string.")
+                if dex_id is not None and not isinstance(dex_id, str):
+                    raise WalletBackendError("dex_id must be a string.")
+                if not isinstance(limit, int) or limit < 1 or limit > 30:
+                    raise WalletBackendError("limit must be an integer between 1 and 30.")
+                data = await active_backend.search_uniswap_pairs(
+                    query=query,
+                    token_address=token_address,
+                    chain=chain,
+                    dex_id=dex_id,
+                    all_chains=all_chains,
+                    limit=limit,
+                )
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
             if tool_name == "swap_evm_uniswap_tokens":
                 token_in = args.get("token_in")
                 token_out = args.get("token_out")
@@ -5750,46 +5921,69 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(active_backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                execute_preview = None
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(active_backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
                     )
-                expected_summary = {
-                    "operation": "Flash Trade open position",
-                    "pool_name": pool_name.strip(),
-                    "market_symbol": market_symbol.strip(),
-                    "collateral_symbol": collateral_symbol.strip(),
-                    "collateral_amount_raw": collateral_amount_raw.strip(),
-                    "leverage": leverage.strip(),
-                    "side": side,
-                }
-                for key, expected_value in expected_summary.items():
-                    if approval_summary.get(key) != expected_value:
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
                             "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
+                    expected_summary = {
+                        "operation": "Flash Trade open position",
+                        "pool_name": pool_name.strip(),
+                        "market_symbol": market_symbol.strip(),
+                        "collateral_symbol": collateral_symbol.strip(),
+                        "collateral_amount_raw": collateral_amount_raw.strip(),
+                        "leverage": leverage.strip(),
+                        "side": side,
+                    }
+                    for key, expected_value in expected_summary.items():
+                        if approval_summary.get(key) != expected_value:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                            )
 
-                approval_summary_copy = dict(approval_summary)
-                approved_preview = args.get("_approved_preview")
-                execute_preview = None
-                if isinstance(approval_summary_copy.get("_preview_digest"), str):
-                    if not isinstance(approved_preview, dict):
-                        raise WalletBackendError(
-                            "Approved Flash Trade preview payload is required for execute mode. Generate a new preview and approval before execute."
-                        )
-                    if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                    approval_summary_copy = dict(approval_summary)
+                    approved_preview = args.get("_approved_preview")
+                    if isinstance(approval_summary_copy.get("_preview_digest"), str):
+                        if not isinstance(approved_preview, dict):
+                            raise WalletBackendError(
+                                "Approved Flash Trade preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            )
+                        if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                            raise WalletBackendError(
+                                "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                            )
+                        execute_preview = dict(approved_preview)
+                    else:
+                        execute_preview = await active_backend.preview_flash_trade_open_position(
+                            pool_name=pool_name.strip(),
+                            market_symbol=market_symbol.strip(),
+                            collateral_symbol=collateral_symbol.strip(),
+                            collateral_amount_raw=collateral_amount_raw.strip(),
+                            leverage=leverage.strip(),
+                            side=side,
                         )
-                    execute_preview = dict(approved_preview)
                 else:
+                    # No host token: build the same identity summary the
+                    # human path validates, and let _require_execute_approval's
+                    # autonomous_session / agentlayer_autonomous_approve
+                    # fallback authorize it.
+                    approval_summary_copy = {
+                        "operation": "Flash Trade open position",
+                        "pool_name": pool_name.strip(),
+                        "market_symbol": market_symbol.strip(),
+                        "collateral_symbol": collateral_symbol.strip(),
+                        "collateral_amount_raw": collateral_amount_raw.strip(),
+                        "leverage": leverage.strip(),
+                        "side": side,
+                    }
                     execute_preview = await active_backend.preview_flash_trade_open_position(
                         pool_name=pool_name.strip(),
                         market_symbol=market_symbol.strip(),
@@ -5879,43 +6073,60 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(active_backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                execute_preview = None
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(active_backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
                     )
-                expected_summary = {
-                    "operation": "Flash Trade close position",
-                    "pool_name": pool_name.strip(),
-                    "market_symbol": market_symbol.strip(),
-                    "side": side,
-                }
-                for key, expected_value in expected_summary.items():
-                    if approval_summary.get(key) != expected_value:
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
                             "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
+                    expected_summary = {
+                        "operation": "Flash Trade close position",
+                        "pool_name": pool_name.strip(),
+                        "market_symbol": market_symbol.strip(),
+                        "side": side,
+                    }
+                    for key, expected_value in expected_summary.items():
+                        if approval_summary.get(key) != expected_value:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                            )
 
-                approval_summary_copy = dict(approval_summary)
-                approved_preview = args.get("_approved_preview")
-                execute_preview = None
-                if isinstance(approval_summary_copy.get("_preview_digest"), str):
-                    if not isinstance(approved_preview, dict):
-                        raise WalletBackendError(
-                            "Approved Flash Trade preview payload is required for execute mode. Generate a new preview and approval before execute."
-                        )
-                    if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                    approval_summary_copy = dict(approval_summary)
+                    approved_preview = args.get("_approved_preview")
+                    if isinstance(approval_summary_copy.get("_preview_digest"), str):
+                        if not isinstance(approved_preview, dict):
+                            raise WalletBackendError(
+                                "Approved Flash Trade preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            )
+                        if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                            raise WalletBackendError(
+                                "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                            )
+                        execute_preview = dict(approved_preview)
+                    else:
+                        execute_preview = await active_backend.preview_flash_trade_close_position(
+                            pool_name=pool_name.strip(),
+                            market_symbol=market_symbol.strip(),
+                            side=side,
                         )
-                    execute_preview = dict(approved_preview)
                 else:
+                    # No host token: build the same identity summary the
+                    # human path validates, and let _require_execute_approval's
+                    # autonomous_session / agentlayer_autonomous_approve
+                    # fallback authorize it.
+                    approval_summary_copy = {
+                        "operation": "Flash Trade close position",
+                        "pool_name": pool_name.strip(),
+                        "market_symbol": market_symbol.strip(),
+                        "side": side,
+                    }
                     execute_preview = await active_backend.preview_flash_trade_close_position(
                         pool_name=pool_name.strip(),
                         market_symbol=market_symbol.strip(),
@@ -6432,44 +6643,60 @@ class OpenClawWalletAdapter:
                     )
 
                 if mode == "intent_execute":
-                    approval_payload = inspect_approval_token(
-                        approval_token,
-                        tool_name=tool_name,
-                        network=str(getattr(self.backend, "network", "unknown")),
-                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
-                    )
-                    approval_summary = approval_payload.get("binding", {}).get("summary")
-                    if not isinstance(approval_summary, dict):
-                        raise WalletBackendError(
-                            "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
+                    if isinstance(approval_token, str) and approval_token.strip():
+                        approval_payload = inspect_approval_token(
+                            approval_token,
+                            tool_name=tool_name,
+                            network=str(getattr(self.backend, "network", "unknown")),
+                            require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
                         )
-                    expected_summary = {
-                        "operation": intent_action_label,
-                        "network": str(getattr(self.backend, "network", "unknown")),
-                        "kvault": kvault.strip(),
-                        "amount_ui": amount_ui.strip(),
-                    }
-                    for key, expected_value in expected_summary.items():
-                        if approval_summary.get(key) != expected_value:
+                        approval_summary = approval_payload.get("binding", {}).get("summary")
+                        if not isinstance(approval_summary, dict):
                             raise WalletBackendError(
-                                f"approval_token does not match the requested {action_label} intent. Generate a fresh intent preview and approval before execute."
+                                "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
                             )
-                    if approval_summary.get("recipient_policy") != "owner-only":
-                        raise WalletBackendError("approved Kamino intent recipient policy is invalid.")
-                    if approval_summary.get("spend_policy") != "exact-amount":
-                        raise WalletBackendError("approved Kamino intent spend policy is invalid.")
-                    current_owner = await self.backend.get_address()
-                    approved_owner = approval_summary.get("owner")
-                    if approved_owner and current_owner and str(approved_owner) != str(current_owner):
-                        raise WalletBackendError(
-                            "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
+                        expected_summary = {
+                            "operation": intent_action_label,
+                            "network": str(getattr(self.backend, "network", "unknown")),
+                            "kvault": kvault.strip(),
+                            "amount_ui": amount_ui.strip(),
+                        }
+                        for key, expected_value in expected_summary.items():
+                            if approval_summary.get(key) != expected_value:
+                                raise WalletBackendError(
+                                    f"approval_token does not match the requested {action_label} intent. Generate a fresh intent preview and approval before execute."
+                                )
+                        if approval_summary.get("recipient_policy") != "owner-only":
+                            raise WalletBackendError("approved Kamino intent recipient policy is invalid.")
+                        if approval_summary.get("spend_policy") != "exact-amount":
+                            raise WalletBackendError("approved Kamino intent spend policy is invalid.")
+                        current_owner = await self.backend.get_address()
+                        approved_owner = approval_summary.get("owner")
+                        if approved_owner and current_owner and str(approved_owner) != str(current_owner):
+                            raise WalletBackendError(
+                                "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
+                            )
+                        valid_until = approval_summary.get("valid_until_epoch_seconds")
+                        if valid_until is not None and int(time.time()) > int(valid_until):
+                            raise WalletBackendError(
+                                "Approved Kamino intent has expired. Create a fresh intent preview."
+                            )
+                        approval_summary_copy = dict(approval_summary)
+                    else:
+                        # No host token: build the exact intent preview a
+                        # human would have seen (same call as
+                        # mode=intent_preview), and let
+                        # _require_execute_approval's autonomous_session /
+                        # agentlayer_autonomous_approve fallback authorize it.
+                        intent_preview = await intent_preview_method(
+                            kvault=kvault.strip(),
+                            amount_ui=amount_ui.strip(),
+                            valid_for_seconds=valid_for_seconds,
                         )
-                    valid_until = approval_summary.get("valid_until_epoch_seconds")
-                    if valid_until is not None and int(time.time()) > int(valid_until):
-                        raise WalletBackendError(
-                            "Approved Kamino intent has expired. Create a fresh intent preview."
+                        approval_summary_copy = self._build_confirmation_summary(
+                            action_label=intent_action_label,
+                            payload=intent_preview,
                         )
-                    approval_summary_copy = dict(approval_summary)
                     self._require_execute_approval(
                         approval_token=approval_token,
                         tool_name=tool_name,
@@ -6525,35 +6752,46 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approved_preview = args.get("_approved_preview")
                 execute_preview = None
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(self.backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approved_preview = args.get("_approved_preview")
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(self.backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
                     )
-                approval_summary_copy = dict(approval_summary)
-                if isinstance(approval_summary_copy.get("_preview_digest"), str):
-                    if not isinstance(approved_preview, dict):
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
-                            f"Approved {action_label} preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
-                    if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                    approval_summary_copy = dict(approval_summary)
+                    if isinstance(approval_summary_copy.get("_preview_digest"), str):
+                        if not isinstance(approved_preview, dict):
+                            raise WalletBackendError(
+                                f"Approved {action_label} preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            )
+                        if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                            raise WalletBackendError(
+                                "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                            )
+                        execute_preview = dict(approved_preview)
+                    else:
+                        execute_preview = await preview_method(
+                            kvault=kvault.strip(),
+                            amount_ui=amount_ui.strip(),
                         )
-                    execute_preview = dict(approved_preview)
                 else:
+                    # No host token: same fallback as intent_execute above.
                     execute_preview = await preview_method(
                         kvault=kvault.strip(),
                         amount_ui=amount_ui.strip(),
                     )
+                    approval_summary_copy = self._build_confirmation_summary(
+                        action_label=action_label,
+                        payload=execute_preview,
+                    )
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
@@ -6676,60 +6914,83 @@ class OpenClawWalletAdapter:
                     )
 
                 if mode == "intent_execute":
-                    approval_payload = inspect_approval_token(
-                        approval_token,
-                        tool_name=tool_name,
-                        network=str(getattr(self.backend, "network", "unknown")),
-                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
-                    )
-                    approval_summary = approval_payload.get("binding", {}).get("summary")
-                    if not isinstance(approval_summary, dict):
-                        raise WalletBackendError(
-                            "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
+                    if isinstance(approval_token, str) and approval_token.strip():
+                        approval_payload = inspect_approval_token(
+                            approval_token,
+                            tool_name=tool_name,
+                            network=str(getattr(self.backend, "network", "unknown")),
+                            require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
                         )
-                    expected_summary = {
-                        "operation": intent_action_label,
-                        "network": str(getattr(self.backend, "network", "unknown")),
-                        "market": market.strip(),
-                        "reserve": reserve.strip(),
-                        "amount_ui": amount_ui.strip(),
-                    }
-                    for key, expected_value in expected_summary.items():
-                        if approval_summary.get(key) != expected_value:
+                        approval_summary = approval_payload.get("binding", {}).get("summary")
+                        if not isinstance(approval_summary, dict):
                             raise WalletBackendError(
-                                f"approval_token does not match the requested {action_label} intent. Generate a fresh intent preview and approval before execute."
+                                "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
                             )
-                    if approval_summary.get("recipient_policy") != "owner-only":
-                        raise WalletBackendError("approved Kamino intent recipient policy is invalid.")
-                    if approval_summary.get("spend_policy") != "exact-amount":
-                        raise WalletBackendError("approved Kamino intent spend policy is invalid.")
-                    current_owner = await self.backend.get_address()
-                    approved_owner = approval_summary.get("owner")
-                    if approved_owner and current_owner and str(approved_owner) != str(current_owner):
-                        raise WalletBackendError(
-                            "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
-                        )
-                    approved_obligation = approval_summary.get("obligation_address")
-                    if (
-                        normalized_obligation_address is not None
-                        and approved_obligation is not None
-                        and str(approved_obligation) != normalized_obligation_address
-                    ):
-                        raise WalletBackendError(
-                            "approval_token does not match the requested obligation. Generate a fresh intent preview and approval before execute."
+                        expected_summary = {
+                            "operation": intent_action_label,
+                            "network": str(getattr(self.backend, "network", "unknown")),
+                            "market": market.strip(),
+                            "reserve": reserve.strip(),
+                            "amount_ui": amount_ui.strip(),
+                        }
+                        for key, expected_value in expected_summary.items():
+                            if approval_summary.get(key) != expected_value:
+                                raise WalletBackendError(
+                                    f"approval_token does not match the requested {action_label} intent. Generate a fresh intent preview and approval before execute."
+                                )
+                        if approval_summary.get("recipient_policy") != "owner-only":
+                            raise WalletBackendError("approved Kamino intent recipient policy is invalid.")
+                        if approval_summary.get("spend_policy") != "exact-amount":
+                            raise WalletBackendError("approved Kamino intent spend policy is invalid.")
+                        current_owner = await self.backend.get_address()
+                        approved_owner = approval_summary.get("owner")
+                        if approved_owner and current_owner and str(approved_owner) != str(current_owner):
+                            raise WalletBackendError(
+                                "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
+                            )
+                        approved_obligation = approval_summary.get("obligation_address")
+                        if (
+                            normalized_obligation_address is not None
+                            and approved_obligation is not None
+                            and str(approved_obligation) != normalized_obligation_address
+                        ):
+                            raise WalletBackendError(
+                                "approval_token does not match the requested obligation. Generate a fresh intent preview and approval before execute."
+                            )
+                        valid_until = approval_summary.get("valid_until_epoch_seconds")
+                        if valid_until is not None and int(time.time()) > int(valid_until):
+                            raise WalletBackendError(
+                                "Approved Kamino intent has expired. Create a fresh intent preview."
+                            )
+                        approval_summary_copy = dict(approval_summary)
+                    else:
+                        # No host token: build the exact intent preview a
+                        # human would have seen (same call as
+                        # mode=intent_preview), and let
+                        # _require_execute_approval's autonomous_session /
+                        # agentlayer_autonomous_approve fallback authorize it.
+                        intent_preview = await intent_preview_method(
+                            market=market.strip(),
+                            reserve=reserve.strip(),
+                            amount_ui=amount_ui.strip(),
+                            obligation_address=normalized_obligation_address,
+                            valid_for_seconds=valid_for_seconds,
                         )
-                    valid_until = approval_summary.get("valid_until_epoch_seconds")
-                    if valid_until is not None and int(time.time()) > int(valid_until):
-                        raise WalletBackendError(
-                            "Approved Kamino intent has expired. Create a fresh intent preview."
+                        if bool(intent_preview.get("requires_obligation_address")):
+                            raise WalletBackendError(
+                                f"{action_label} requires obligation_address when multiple Kamino obligations match the selected position."
+                            )
+                        approval_summary_copy = self._build_confirmation_summary(
+                            action_label=intent_action_label,
+                            payload=intent_preview,
                         )
-                    approval_summary_copy = dict(approval_summary)
                     self._require_execute_approval(
                         approval_token=approval_token,
                         tool_name=tool_name,
                         summary=approval_summary_copy,
                         action_label=intent_action_label,
                     )
+                    approved_obligation = approval_summary_copy.get("obligation_address")
                     result = await execute_method(
                         market=market.strip(),
                         reserve=reserve.strip(),
@@ -6793,37 +7054,50 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approved_preview = args.get("_approved_preview")
                 execute_preview = None
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(self.backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approved_preview = args.get("_approved_preview")
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(self.backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
                     )
-                approval_summary_copy = dict(approval_summary)
-                if isinstance(approval_summary_copy.get("_preview_digest"), str):
-                    if not isinstance(approved_preview, dict):
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
-                            f"Approved {action_label} preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
-                    if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                    approval_summary_copy = dict(approval_summary)
+                    if isinstance(approval_summary_copy.get("_preview_digest"), str):
+                        if not isinstance(approved_preview, dict):
+                            raise WalletBackendError(
+                                f"Approved {action_label} preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            )
+                        if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                            raise WalletBackendError(
+                                "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                            )
+                        execute_preview = dict(approved_preview)
+                    else:
+                        execute_preview = await preview_method(
+                            market=market.strip(),
+                            reserve=reserve.strip(),
+                            amount_ui=amount_ui.strip(),
+                            obligation_address=obligation_address.strip() if isinstance(obligation_address, str) and obligation_address.strip() else None,
                         )
-                    execute_preview = dict(approved_preview)
                 else:
+                    # No host token: same fallback as intent_execute above.
                     execute_preview = await preview_method(
                         market=market.strip(),
                         reserve=reserve.strip(),
                         amount_ui=amount_ui.strip(),
                         obligation_address=obligation_address.strip() if isinstance(obligation_address, str) and obligation_address.strip() else None,
                     )
+                    approval_summary_copy = self._build_confirmation_summary(
+                        action_label=action_label,
+                        payload=execute_preview,
+                    )
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
@@ -7123,55 +7397,75 @@ class OpenClawWalletAdapter:
                     )
 
                 if mode == "intent_execute":
-                    approval_payload = inspect_approval_token(
-                        approval_token,
-                        tool_name=tool_name,
-                        network=str(getattr(self.backend, "network", "unknown")),
-                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
-                    )
-                    approval_summary = approval_payload.get("binding", {}).get("summary")
-                    if not isinstance(approval_summary, dict):
-                        raise WalletBackendError(
-                            "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
+                    if isinstance(approval_token, str) and approval_token.strip():
+                        approval_payload = inspect_approval_token(
+                            approval_token,
+                            tool_name=tool_name,
+                            network=str(getattr(self.backend, "network", "unknown")),
+                            require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
                         )
-                    expected_summary = {
-                        "operation": "Swap intent",
-                        "network": str(getattr(self.backend, "network", "unknown")),
-                        "input_mint": input_mint.strip(),
-                        "output_mint": output_mint.strip(),
-                    }
-                    for key, expected_value in expected_summary.items():
-                        if approval_summary.get(key) != expected_value:
+                        approval_summary = approval_payload.get("binding", {}).get("summary")
+                        if not isinstance(approval_summary, dict):
+                            raise WalletBackendError(
+                                "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
+                            )
+                        expected_summary = {
+                            "operation": "Swap intent",
+                            "network": str(getattr(self.backend, "network", "unknown")),
+                            "input_mint": input_mint.strip(),
+                            "output_mint": output_mint.strip(),
+                        }
+                        for key, expected_value in expected_summary.items():
+                            if approval_summary.get(key) != expected_value:
+                                raise WalletBackendError(
+                                    "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                                )
+                        current_owner = await self.backend.get_address()
+                        approved_owner = approval_summary.get("owner")
+                        if approved_owner and current_owner and str(approved_owner) != str(current_owner):
+                            raise WalletBackendError(
+                                "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
+                            )
+                        try:
+                            approved_amount = float(approval_summary.get("input_amount_ui"))
+                            approved_slippage = int(
+                                approval_summary.get("max_slippage_bps")
+                                if approval_summary.get("max_slippage_bps") is not None
+                                else approval_summary.get("slippage_bps")
+                            )
+                        except (TypeError, ValueError):
                             raise WalletBackendError(
                                 "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
                             )
-                    current_owner = await self.backend.get_address()
-                    approved_owner = approval_summary.get("owner")
-                    if approved_owner and current_owner and str(approved_owner) != str(current_owner):
-                        raise WalletBackendError(
-                            "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
-                        )
-                    try:
-                        approved_amount = float(approval_summary.get("input_amount_ui"))
-                        approved_slippage = int(
-                            approval_summary.get("max_slippage_bps")
-                            if approval_summary.get("max_slippage_bps") is not None
-                            else approval_summary.get("slippage_bps")
-                        )
-                    except (TypeError, ValueError):
-                        raise WalletBackendError(
-                            "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                        if approved_amount != float(amount) or approved_slippage != slippage_bps:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                            )
+                        if approval_summary.get("recipient_policy") != "owner-only":
+                            raise WalletBackendError("approved swap intent recipient policy is invalid.")
+                        if approval_summary.get("spend_policy") != "exact-input":
+                            raise WalletBackendError("approved swap intent spend policy is invalid.")
+
+                        approval_summary_copy = dict(approval_summary)
+                    else:
+                        # No host token: build the exact intent preview a human
+                        # would have seen (same call as mode=intent_preview),
+                        # and let _require_execute_approval's autonomous_session /
+                        # agentlayer_autonomous_approve fallback authorize it.
+                        intent_preview = await self.backend.preview_swap_intent(
+                            input_mint=input_mint.strip(),
+                            output_mint=output_mint.strip(),
+                            amount_ui=float(amount),
+                            slippage_bps=slippage_bps,
+                            minimum_output_amount_raw=minimum_output_amount_raw,
+                            max_fee_lamports=max_fee_lamports,
+                            valid_for_seconds=valid_for_seconds,
+                            max_attempts=max_attempts,
                         )
-                    if approved_amount != float(amount) or approved_slippage != slippage_bps:
-                        raise WalletBackendError(
-                            "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                        approval_summary_copy = self._build_confirmation_summary(
+                            action_label="Swap intent",
+                            payload=intent_preview,
                         )
-                    if approval_summary.get("recipient_policy") != "owner-only":
-                        raise WalletBackendError("approved swap intent recipient policy is invalid.")
-                    if approval_summary.get("spend_policy") != "exact-input":
-                        raise WalletBackendError("approved swap intent spend policy is invalid.")
-
-                    approval_summary_copy = dict(approval_summary)
                     self._require_execute_approval(
                         approval_token=approval_token,
                         tool_name=tool_name,
@@ -7219,59 +7513,75 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(self.backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(self.backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
                     )
-                expected_summary = {
-                    "operation": "Swap",
-                    "network": str(getattr(self.backend, "network", "unknown")),
-                    "input_mint": input_mint.strip(),
-                    "output_mint": output_mint.strip(),
-                    "slippage_bps": slippage_bps,
-                }
-                for key, expected_value in expected_summary.items():
-                    if approval_summary.get(key) != expected_value:
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
                             "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
-                try:
-                    approved_amount = float(approval_summary.get("input_amount_ui"))
-                except (TypeError, ValueError):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
-                    )
-                if approved_amount != float(amount):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
-                    )
-
-                approval_summary_copy = dict(approval_summary)
-                approved_preview = args.get("_approved_preview")
-                if isinstance(approval_summary_copy.get("_preview_digest"), str):
-                    if not isinstance(approved_preview, dict):
+                    expected_summary = {
+                        "operation": "Swap",
+                        "network": str(getattr(self.backend, "network", "unknown")),
+                        "input_mint": input_mint.strip(),
+                        "output_mint": output_mint.strip(),
+                        "slippage_bps": slippage_bps,
+                    }
+                    for key, expected_value in expected_summary.items():
+                        if approval_summary.get(key) != expected_value:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                            )
+                    try:
+                        approved_amount = float(approval_summary.get("input_amount_ui"))
+                    except (TypeError, ValueError):
                         raise WalletBackendError(
-                            "Approved swap preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
-                    if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                    if approved_amount != float(amount):
                         raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                            "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                        )
+
+                    approval_summary_copy = dict(approval_summary)
+                    approved_preview = args.get("_approved_preview")
+                    if isinstance(approval_summary_copy.get("_preview_digest"), str):
+                        if not isinstance(approved_preview, dict):
+                            raise WalletBackendError(
+                                "Approved swap preview payload is required for execute mode. Generate a new preview and approval before execute."
+                            )
+                        if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                            raise WalletBackendError(
+                                "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                            )
+                        execute_preview = dict(approved_preview)
+                    else:
+                        execute_preview = await self.backend.preview_swap(
+                            input_mint=input_mint.strip(),
+                            output_mint=output_mint.strip(),
+                            amount_ui=float(amount),
+                            slippage_bps=slippage_bps,
                         )
-                    execute_preview = dict(approved_preview)
                 else:
+                    # No host token: same fallback as intent_execute above --
+                    # build a fresh preview and let _require_execute_approval's
+                    # autonomous_session / agentlayer_autonomous_approve
+                    # fallback authorize it.
                     execute_preview = await self.backend.preview_swap(
                         input_mint=input_mint.strip(),
                         output_mint=output_mint.strip(),
                         amount_ui=float(amount),
                         slippage_bps=slippage_bps,
                     )
+                    approval_summary_copy = self._build_confirmation_summary(
+                        action_label="Swap",
+                        payload=execute_preview,
+                    )
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
@@ -7362,54 +7672,65 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                approval_payload = inspect_approval_token(
-                    approval_token,
-                    tool_name=tool_name,
-                    network=str(getattr(self.backend, "network", "unknown")),
-                    require_mainnet_confirmation=self._is_mainnet(),
-                )
-                approval_summary = approval_payload.get("binding", {}).get("summary")
-                if not isinstance(approval_summary, dict):
-                    raise WalletBackendError(
-                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                if isinstance(approval_token, str) and approval_token.strip():
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(self.backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet(),
                     )
-                destination_chain_id = self._canonicalize_lifi_chain_identifier(destination_chain)
-                expected_summary = {
-                    "operation": "Solana LI.FI cross-chain swap",
-                    "network": str(getattr(self.backend, "network", "unknown")),
-                    "source_chain": "solana",
-                    "destination_chain": destination_chain_id,
-                    "input_token": self._canonicalize_lifi_token_identifier(
-                        input_token,
-                        chain_id="1151111081099710",
-                    ),
-                    "output_token": self._canonicalize_lifi_token_identifier(
-                        output_token,
-                        chain_id=destination_chain_id,
-                    ),
-                    "destination_address": destination_address.strip(),
-                    "input_amount_raw": amount_in_raw.strip(),
-                }
-                for key, expected_value in expected_summary.items():
-                    actual_value = approval_summary.get(key)
-                    if key == "destination_chain":
-                        actual_value = self._canonicalize_lifi_chain_identifier(actual_value)
-                    if key == "input_token":
-                        actual_value = self._canonicalize_lifi_token_identifier(
-                            actual_value,
-                            chain_id="1151111081099710",
-                        )
-                    if key == "output_token":
-                        actual_value = self._canonicalize_lifi_token_identifier(
-                            actual_value,
-                            chain_id=destination_chain_id,
-                        )
-                    if actual_value != expected_value:
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
                         raise WalletBackendError(
                             "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
                         )
+                    destination_chain_id = self._canonicalize_lifi_chain_identifier(destination_chain)
+                    expected_summary = {
+                        "operation": "Solana LI.FI cross-chain swap",
+                        "network": str(getattr(self.backend, "network", "unknown")),
+                        "source_chain": "solana",
+                        "destination_chain": destination_chain_id,
+                        "input_token": self._canonicalize_lifi_token_identifier(
+                            input_token,
+                            chain_id="1151111081099710",
+                        ),
+                        "output_token": self._canonicalize_lifi_token_identifier(
+                            output_token,
+                            chain_id=destination_chain_id,
+                        ),
+                        "destination_address": destination_address.strip(),
+                        "input_amount_raw": amount_in_raw.strip(),
+                    }
+                    for key, expected_value in expected_summary.items():
+                        actual_value = approval_summary.get(key)
+                        if key == "destination_chain":
+                            actual_value = self._canonicalize_lifi_chain_identifier(actual_value)
+                        if key == "input_token":
+                            actual_value = self._canonicalize_lifi_token_identifier(
+                                actual_value,
+                                chain_id="1151111081099710",
+                            )
+                        if key == "output_token":
+                            actual_value = self._canonicalize_lifi_token_identifier(
+                                actual_value,
+                                chain_id=destination_chain_id,
+                            )
+                        if actual_value != expected_value:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                            )
 
-                approval_summary_copy = dict(approval_summary)
+                    approval_summary_copy = dict(approval_summary)
+                else:
+                    # No host token: build the exact preview a human would
+                    # have seen and let _require_execute_approval's
+                    # autonomous_session / agentlayer_autonomous_approve
+                    # fallback authorize it.
+                    fresh_preview = await self.backend.preview_solana_lifi_cross_chain_swap(**preview_kwargs)
+                    approval_summary_copy = self._build_confirmation_summary(
+                        action_label="Solana LI.FI cross-chain swap",
+                        payload=fresh_preview,
+                    )
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,