@agentlayer.tech/wallet 0.1.47 → 0.1.49

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 import hashlib
 import json
+import time
 from typing import Any
 
 from agent_wallet.approval import inspect_approval_token, verify_approval_token
+from agent_wallet.autonomous_policy import OperationRequest
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.models import AgentToolResult, AgentToolSpec
 from agent_wallet.providers import x402
@@ -278,6 +280,113 @@ class OpenClawWalletAdapter:
             ),
         ]
 
+    @staticmethod
+    def _autonomous_signals(summary: dict[str, Any]) -> tuple[str | None, int | None]:
+        """Best-effort extraction of (recipient, smallest-unit spend) from a summary.
+
+        Only raw/base-unit amount fields are trusted for spend accounting; a
+        UI-denominated amount is ignored so caps are never applied at the wrong
+        scale. When no raw amount is present the spend is reported as ``None``
+        (unknown), which the session layer treats as fail-closed when caps are
+        configured.
+        """
+        recipient: str | None = None
+        for key in ("to_address", "to", "recipient", "destination", "destination_address", "spender"):
+            value = summary.get(key)
+            if isinstance(value, str) and value.strip():
+                recipient = value.strip()
+                break
+
+        spend: int | None = None
+        for key in ("input_amount_raw", "amount_raw", "amount_wei", "amount_lamports", "amount_base_units"):
+            value = summary.get(key)
+            if value is None:
+                continue
+            try:
+                spend = int(str(value))
+            except (TypeError, ValueError):
+                continue
+            break
+        return recipient, spend
+
+    def _build_session_config_from_args(self, args: dict[str, Any]):
+        """Construct an AutonomousSessionConfig from start_autonomous_session args."""
+        from agent_wallet.autonomous_policy import AutonomousSessionConfig
+        from agent_wallet.spending_limits import SpendingConfig
+
+        def _str_list(value: Any, field: str) -> list[str]:
+            if value is None:
+                return []
+            if not isinstance(value, list) or any(not isinstance(v, str) or not v.strip() for v in value):
+                raise WalletBackendError(f"{field} must be an array of non-empty strings.")
+            return [v.strip() for v in value]
+
+        def _int(value: Any, field: str) -> int:
+            if value is None:
+                return 0
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise WalletBackendError(f"{field} must be a non-negative integer.")
+            return value
+
+        return AutonomousSessionConfig(
+            enabled=True,
+            allowed_tools=frozenset(_str_list(args.get("allowed_tools"), "allowed_tools")),
+            allowed_networks=frozenset(_str_list(args.get("allowed_networks"), "allowed_networks")),
+            allow_mainnet=bool(args.get("allow_mainnet", False)),
+            allowed_recipients=frozenset(_str_list(args.get("allowed_recipients"), "allowed_recipients")),
+            allow_any_recipient=bool(args.get("allow_any_recipient", False)),
+            require_simulation=bool(args.get("require_simulation", True)),
+            spending=SpendingConfig(
+                max_per_tx_lamports=_int(args.get("max_per_tx_lamports"), "max_per_tx_lamports"),
+                max_hourly_lamports=_int(args.get("max_hourly_lamports"), "max_hourly_lamports"),
+                max_daily_lamports=_int(args.get("max_daily_lamports"), "max_daily_lamports"),
+                max_txs_per_minute=_int(args.get("max_txs_per_minute"), "max_txs_per_minute"),
+            ),
+            max_operations=_int(args.get("max_operations"), "max_operations"),
+            session_ttl_seconds=_int(args.get("session_ttl_seconds"), "session_ttl_seconds"),
+            approval_ttl_seconds=_int(args.get("approval_ttl_seconds"), "approval_ttl_seconds") or 120,
+        )
+
+    async def _authorize_base_swap_permission(
+        self,
+        *,
+        active_backend: AgentWalletBackend,
+        tool_name: str,
+        action_label: str,
+        preview_kwargs: dict[str, Any],
+        preview_method: Any,
+    ) -> tuple[str, dict[str, Any]]:
+        """Authorize one Base swap through the high-trust permission toggle."""
+        from agent_wallet import autonomous_permissions
+
+        network = str(getattr(active_backend, "network", "unknown")).strip().lower()
+        if network != autonomous_permissions.BASE_SWAP_NETWORK:
+            raise WalletBackendError(
+                "Autonomous Base swap permission only applies on network=base. "
+                "Use set_evm_network or the network parameter to select Base."
+            )
+        if not autonomous_permissions.is_base_swap_approved():
+            raise WalletBackendError(
+                "Autonomous Base swap permission is not enabled. Ask the user to run "
+                "agentlayer_autonomous_approve with scope=base_swaps first."
+            )
+
+        preview = await preview_method(**preview_kwargs)
+        annotated_preview = self._annotate_sensitive_payload(
+            preview,
+            action_label=action_label,
+            mode="preview",
+        )
+        summary = dict(annotated_preview.get("confirmation_summary") or {})
+        if not summary:
+            raise WalletBackendError("Autonomous Base swap preview did not produce a confirmation_summary.")
+        token = autonomous_permissions.authorize_base_swap(
+            tool_name=tool_name,
+            network=network,
+            summary=summary,
+        )
+        return token, summary
+
     def _require_execute_approval(
         self,
         *,
@@ -288,10 +397,31 @@ class OpenClawWalletAdapter:
         backend: AgentWalletBackend | None = None,
     ) -> None:
         active_backend = backend or self.backend
+        network = str(getattr(active_backend, "network", "unknown"))
         if not isinstance(approval_token, str) or not approval_token.strip():
-            raise WalletBackendError(
-                f"{action_label} execution requires a host-issued approval_token."
-            )
+            # No host token: fall back to the autonomous policy engine if (and
+            # only if) a human-authorized session envelope is active. The engine
+            # mints the same signed token the host would, so verification below
+            # is identical for both paths.
+            from agent_wallet import autonomous_session
+
+            if autonomous_session.is_active():
+                recipient, spend = self._autonomous_signals(summary)
+                approval_token = autonomous_session.authorize_operation(
+                    OperationRequest(
+                        tool_name=tool_name,
+                        network=network,
+                        summary=summary,
+                        spend_amount=spend,
+                        recipient=recipient,
+                        simulated=True,
+                    )
+                )
+            else:
+                raise WalletBackendError(
+                    f"{action_label} execution requires a host-issued approval_token "
+                    "(or an active autonomous session authorized by the host)."
+                )
         verify_approval_token(
             approval_token.strip(),
             tool_name=tool_name,
@@ -371,6 +501,24 @@ class OpenClawWalletAdapter:
                 "spend_policy": payload.get("spend_policy"),
             }
 
+        if asset_type == "kamino-lend-intent":
+            summary = {
+                "operation": action_label,
+                "network": str(payload.get("network") or getattr(self.backend, "network", "unknown")),
+                "owner": payload.get("owner"),
+                "kamino_operation": payload.get("kamino_operation"),
+                "market": payload.get("market"),
+                "reserve": payload.get("reserve"),
+                "amount_ui": payload.get("amount_ui"),
+                "recipient_policy": payload.get("recipient_policy"),
+                "spend_policy": payload.get("spend_policy"),
+                "valid_until_epoch_seconds": payload.get("valid_until_epoch_seconds"),
+            }
+            obligation_address = payload.get("obligation_address")
+            if obligation_address is not None:
+                summary["obligation_address"] = obligation_address
+            return summary
+
         if asset_type == "solana-lifi-cross-chain-swap":
             return {
                 "operation": action_label,
@@ -1804,7 +1952,8 @@ class OpenClawWalletAdapter:
                         name="swap_evm_tokens",
                         description=(
                             "Preview, prepare, or execute an ERC-20 or native ETH swap through Velora on supported EVM mainnet networks. "
-                            "Prepare returns an execution plan only, and execute requires a host-issued approval token bound to the previewed operation."
+                            "Prepare returns an execution plan only, and execute requires a host-issued approval token bound to the previewed operation "
+                            "unless high-trust autonomous Base swaps are enabled with scope=base_swaps."
                         ),
                         input_schema={
                             "type": "object",
@@ -1959,7 +2108,8 @@ class OpenClawWalletAdapter:
                         description=(
                             "Preview, prepare, or execute an ERC-20 or native ETH swap through the Uniswap Trading API "
                             "(CLASSIC routing) on ethereum or base. ERC-20 inputs use Permit2 EIP-712 signing automatically. "
-                            "Prepare returns an execution plan only. Execute requires a host-issued approval token bound to the previewed operation."
+                            "Prepare returns an execution plan only. Execute requires a host-issued approval token bound to the previewed operation "
+                            "unless high-trust autonomous Base swaps are enabled with scope=base_swaps."
                         ),
                         input_schema={
                             "type": "object",
@@ -2037,6 +2187,7 @@ class OpenClawWalletAdapter:
                     ),
                 )
 
+            tools.extend(self._autonomous_permission_tool_specs())
             return tools
 
         if capabilities.chain == "bitcoin":
@@ -3000,12 +3151,16 @@ class OpenClawWalletAdapter:
                             },
                             "mode": {
                                 "type": "string",
-                                "enum": ["preview", "prepare", "execute"],
-                                "description": "preview returns a summary, prepare returns an execution plan without signed transaction bytes, execute attempts to submit the Kamino deposit transaction.",
+                                "enum": ["preview", "prepare", "execute", "intent_preview", "intent_execute"],
+                                "description": "Prefer intent_preview then intent_execute after explicit chat confirmation: intent_execute re-derives the Kamino transaction and executes within the approved parameters without round-tripping the preview payload. Legacy preview/prepare/execute remains supported.",
+                            },
+                            "valid_for_seconds": {
+                                "type": "integer",
+                                "description": "Optional intent validity window in seconds for intent_preview (1-300, default 120).",
                             },
                             "purpose": {"type": "string", "description": "Short explanation of why the deposit is being made."},
                             "user_intent": {"type": "boolean", "description": "Must be true for prepare mode."},
-                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute mode."},
+                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute/intent_execute mode."},
                         },
                         "required": ["market", "reserve", "amount_ui", "mode", "purpose"],
                         "additionalProperties": False,
@@ -3038,12 +3193,16 @@ class OpenClawWalletAdapter:
                             },
                             "mode": {
                                 "type": "string",
-                                "enum": ["preview", "prepare", "execute"],
-                                "description": "preview returns a summary, prepare returns an execution plan without signed transaction bytes, execute attempts to submit the Kamino withdraw transaction.",
+                                "enum": ["preview", "prepare", "execute", "intent_preview", "intent_execute"],
+                                "description": "Prefer intent_preview then intent_execute after explicit chat confirmation: intent_execute re-derives the Kamino transaction and executes within the approved parameters without round-tripping the preview payload. Legacy preview/prepare/execute remains supported.",
+                            },
+                            "valid_for_seconds": {
+                                "type": "integer",
+                                "description": "Optional intent validity window in seconds for intent_preview (1-300, default 120).",
                             },
                             "purpose": {"type": "string", "description": "Short explanation of why the withdraw is being made."},
                             "user_intent": {"type": "boolean", "description": "Must be true for prepare mode."},
-                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute mode."},
+                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute/intent_execute mode."},
                         },
                         "required": ["market", "reserve", "amount_ui", "mode", "purpose"],
                         "additionalProperties": False,
@@ -3076,12 +3235,16 @@ class OpenClawWalletAdapter:
                             },
                             "mode": {
                                 "type": "string",
-                                "enum": ["preview", "prepare", "execute"],
-                                "description": "preview returns a summary, prepare returns an execution plan without signed transaction bytes, execute attempts to submit the Kamino borrow transaction.",
+                                "enum": ["preview", "prepare", "execute", "intent_preview", "intent_execute"],
+                                "description": "Prefer intent_preview then intent_execute after explicit chat confirmation: intent_execute re-derives the Kamino transaction and executes within the approved parameters without round-tripping the preview payload. Legacy preview/prepare/execute remains supported.",
+                            },
+                            "valid_for_seconds": {
+                                "type": "integer",
+                                "description": "Optional intent validity window in seconds for intent_preview (1-300, default 120).",
                             },
                             "purpose": {"type": "string", "description": "Short explanation of why the borrow is being made."},
                             "user_intent": {"type": "boolean", "description": "Must be true for prepare mode."},
-                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute mode."},
+                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute/intent_execute mode."},
                         },
                         "required": ["market", "reserve", "amount_ui", "mode", "purpose"],
                         "additionalProperties": False,
@@ -3114,12 +3277,16 @@ class OpenClawWalletAdapter:
                             },
                             "mode": {
                                 "type": "string",
-                                "enum": ["preview", "prepare", "execute"],
-                                "description": "preview returns a summary, prepare returns an execution plan without signed transaction bytes, execute attempts to submit the Kamino repay transaction.",
+                                "enum": ["preview", "prepare", "execute", "intent_preview", "intent_execute"],
+                                "description": "Prefer intent_preview then intent_execute after explicit chat confirmation: intent_execute re-derives the Kamino transaction and executes within the approved parameters without round-tripping the preview payload. Legacy preview/prepare/execute remains supported.",
+                            },
+                            "valid_for_seconds": {
+                                "type": "integer",
+                                "description": "Optional intent validity window in seconds for intent_preview (1-300, default 120).",
                             },
                             "purpose": {"type": "string", "description": "Short explanation of why the repay is being made."},
                             "user_intent": {"type": "boolean", "description": "Must be true for prepare mode."},
-                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute mode."},
+                            "approval_token": {"type": "string", "description": "Host-issued approval token required for execute/intent_execute mode."},
                         },
                         "required": ["market", "reserve", "amount_ui", "mode", "purpose"],
                         "additionalProperties": False,
@@ -3259,6 +3426,176 @@ class OpenClawWalletAdapter:
                 )
             )
 
+        tools.append(
+            AgentToolSpec(
+                name="get_autonomous_session",
+                description=(
+                    "Return the status of the current autonomous execution session, if any: "
+                    "whether it is active, its allow-lists, spend limits, operation count, and expiry. "
+                    "Read-only."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            )
+        )
+        tools.append(
+            AgentToolSpec(
+                name="start_autonomous_session",
+                description=(
+                    "Start an autonomous execution session so subsequent wallet writes can execute "
+                    "WITHOUT a per-transaction human approval, bounded by the supplied limits. "
+                    "This grants standing authority, so it requires a host-issued approval_token bound "
+                    "to the exact session policy; an agent cannot start a session on its own. "
+                    "Preview the policy first (mode=preview) to obtain the confirmation summary the host signs."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "mode": {
+                            "type": "string",
+                            "enum": ["preview", "execute"],
+                            "description": "preview returns the policy summary to be confirmed; execute starts the session.",
+                        },
+                        "allowed_tools": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "Wallet tools the agent may execute autonomously.",
+                        },
+                        "allowed_networks": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "Networks the agent may operate on autonomously.",
+                        },
+                        "allow_mainnet": {
+                            "type": "boolean",
+                            "description": "Must be true to permit autonomous execution on real-money networks.",
+                        },
+                        "allowed_recipients": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "Destination addresses the agent may send to.",
+                        },
+                        "allow_any_recipient": {
+                            "type": "boolean",
+                            "description": "Allow destinations not on the allow-list (spend caps and simulation still apply).",
+                        },
+                        "require_simulation": {
+                            "type": "boolean",
+                            "description": "Require a passing simulation before each autonomous execute (default true).",
+                        },
+                        "max_per_tx_lamports": {"type": "integer", "description": "Per-transaction spend cap in smallest units (0 = unlimited)."},
+                        "max_hourly_lamports": {"type": "integer", "description": "Hourly cumulative spend cap (0 = unlimited)."},
+                        "max_daily_lamports": {"type": "integer", "description": "Daily cumulative spend cap (0 = unlimited)."},
+                        "max_txs_per_minute": {"type": "integer", "description": "Transaction rate cap per minute (0 = unlimited)."},
+                        "max_operations": {"type": "integer", "description": "Maximum operations the session may approve (0 = unlimited)."},
+                        "session_ttl_seconds": {"type": "integer", "description": "Session lifetime in seconds (0 = no expiry)."},
+                        "approval_ttl_seconds": {"type": "integer", "description": "TTL applied to each auto-issued approval token (default 120)."},
+                        "approval_token": {
+                            "type": "string",
+                            "description": "Host-issued approval token bound to this session policy. Required for mode=execute.",
+                        },
+                    },
+                    "required": ["mode"],
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                risk_level="high",
+            )
+        )
+        tools.append(
+            AgentToolSpec(
+                name="stop_autonomous_session",
+                description=(
+                    "End the current autonomous execution session. Always allowed; this only removes "
+                    "standing authority and returns the wallet to per-transaction human approval."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                risk_level="low",
+            )
+        )
+        tools.append(
+            AgentToolSpec(
+                name="agentlayer_autonomous_status",
+                description=(
+                    "Return AgentLayer high-trust autonomous permission status. "
+                    "Currently supports only scope=base_swaps."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            )
+        )
+        tools.append(
+            AgentToolSpec(
+                name="agentlayer_autonomous_approve",
+                description=(
+                    "Enable high-trust autonomous execution for a narrow scope. "
+                    "Currently scope=base_swaps lets Base Velora/Uniswap swap execute calls run "
+                    "without per-transaction human approval until revoked. This does not cover "
+                    "transfers, withdrawals, lending, staking, bridges, Solana swaps, or non-Base networks."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "scope": {
+                            "type": "string",
+                            "enum": ["base_swaps"],
+                            "description": "Only base_swaps is currently supported.",
+                        },
+                        "purpose": {
+                            "type": "string",
+                            "description": "Short explanation of why the standing permission is being enabled.",
+                        },
+                        "user_intent": {
+                            "type": "boolean",
+                            "description": "Must be true after the user explicitly asks to enable this permission.",
+                        },
+                    },
+                    "required": ["scope", "purpose", "user_intent"],
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                risk_level="high",
+            )
+        )
+        tools.append(
+            AgentToolSpec(
+                name="agentlayer_autonomous_revoke",
+                description=(
+                    "Disable high-trust autonomous execution for a scope. "
+                    "Currently supports only scope=base_swaps."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "scope": {
+                            "type": "string",
+                            "enum": ["base_swaps"],
+                            "description": "Only base_swaps is currently supported.",
+                        }
+                    },
+                    "required": ["scope"],
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                risk_level="low",
+            )
+        )
+
         tools.extend(self._x402_tool_specs())
         return tools
 
@@ -3266,12 +3603,170 @@ class OpenClawWalletAdapter:
         """Return the instruction block to inject into the agent runtime."""
         return WALLET_RUNTIME_INSTRUCTIONS
 
+    @staticmethod
+    def _autonomous_permission_tool_specs() -> list[AgentToolSpec]:
+        return [
+            AgentToolSpec(
+                name="agentlayer_autonomous_status",
+                description=(
+                    "Return AgentLayer high-trust autonomous permission status. "
+                    "Currently supports only scope=base_swaps."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            ),
+            AgentToolSpec(
+                name="agentlayer_autonomous_approve",
+                description=(
+                    "Enable high-trust autonomous execution for a narrow scope. "
+                    "Currently scope=base_swaps lets Base Velora/Uniswap swap execute calls run "
+                    "without per-transaction human approval until revoked. This does not cover "
+                    "transfers, withdrawals, lending, staking, bridges, Solana swaps, or non-Base networks."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "scope": {
+                            "type": "string",
+                            "enum": ["base_swaps"],
+                            "description": "Only base_swaps is currently supported.",
+                        },
+                        "purpose": {
+                            "type": "string",
+                            "description": "Short explanation of why the standing permission is being enabled.",
+                        },
+                        "user_intent": {
+                            "type": "boolean",
+                            "description": "Must be true after the user explicitly asks to enable this permission.",
+                        },
+                    },
+                    "required": ["scope", "purpose", "user_intent"],
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                risk_level="high",
+            ),
+            AgentToolSpec(
+                name="agentlayer_autonomous_revoke",
+                description=(
+                    "Disable high-trust autonomous execution for a scope. "
+                    "Currently supports only scope=base_swaps."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "scope": {
+                            "type": "string",
+                            "enum": ["base_swaps"],
+                            "description": "Only base_swaps is currently supported.",
+                        }
+                    },
+                    "required": ["scope"],
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                risk_level="low",
+            ),
+        ]
+
     async def invoke(self, tool_name: str, arguments: dict[str, Any] | None = None) -> AgentToolResult:
         """Dispatch an agent-facing tool call to the wallet backend."""
         args = arguments or {}
         try:
             active_backend = self._resolve_backend_for_args(args)
 
+            if tool_name == "get_autonomous_session":
+                from agent_wallet import autonomous_session
+
+                return AgentToolResult(tool=tool_name, ok=True, data=autonomous_session.session_status())
+
+            if tool_name == "stop_autonomous_session":
+                from agent_wallet import autonomous_session
+
+                return AgentToolResult(tool=tool_name, ok=True, data=autonomous_session.stop_session())
+
+            if tool_name == "agentlayer_autonomous_status":
+                from agent_wallet import autonomous_permissions
+
+                return AgentToolResult(tool=tool_name, ok=True, data=autonomous_permissions.status())
+
+            if tool_name == "agentlayer_autonomous_approve":
+                from agent_wallet import autonomous_permissions
+
+                scope = str(args.get("scope") or "").strip()
+                purpose = args.get("purpose")
+                if scope != autonomous_permissions.BASE_SWAP_SCOPE:
+                    raise WalletBackendError("Only scope=base_swaps is currently supported.")
+                if not isinstance(purpose, str) or not purpose.strip():
+                    raise WalletBackendError("purpose is required.")
+                if args.get("user_intent") is not True:
+                    raise WalletBackendError(
+                        "agentlayer_autonomous_approve requires user_intent=true after the user explicitly asks for this permission."
+                    )
+                return AgentToolResult(
+                    tool=tool_name,
+                    ok=True,
+                    data=autonomous_permissions.approve_base_swaps(approved_by="agentlayer_autonomous_approve"),
+                )
+
+            if tool_name == "agentlayer_autonomous_revoke":
+                from agent_wallet import autonomous_permissions
+
+                scope = str(args.get("scope") or "").strip()
+                if scope != autonomous_permissions.BASE_SWAP_SCOPE:
+                    raise WalletBackendError("Only scope=base_swaps is currently supported.")
+                return AgentToolResult(
+                    tool=tool_name,
+                    ok=True,
+                    data=autonomous_permissions.revoke_base_swaps(),
+                )
+
+            if tool_name == "start_autonomous_session":
+                from agent_wallet import autonomous_session
+                from agent_wallet.autonomous_session import config_to_dict
+                from agent_wallet.nonce_registry import require_single_use
+
+                config = self._build_session_config_from_args(args)
+                policy_summary = {"operation": "start_autonomous_session", **config_to_dict(config)}
+                mode = str(args.get("mode") or "").strip().lower()
+                if mode not in {"preview", "execute"}:
+                    raise WalletBackendError("mode must be 'preview' or 'execute'.")
+                if mode == "preview":
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data={
+                            "mode": "preview",
+                            "confirmation_summary": policy_summary,
+                            "execute_requires_approval_token": True,
+                            "approval_hint": {"host_must_issue_token_for": policy_summary},
+                        },
+                    )
+                # execute: starting a session grants standing authority, so it
+                # always requires a genuine host token — never the autonomous
+                # fallback (an agent must not be able to widen its own envelope).
+                approval_token = args.get("approval_token")
+                if not isinstance(approval_token, str) or not approval_token.strip():
+                    raise WalletBackendError(
+                        "start_autonomous_session execute requires a host-issued approval_token "
+                        "bound to the previewed session policy."
+                    )
+                verify_approval_token(
+                    approval_token.strip(),
+                    tool_name="start_autonomous_session",
+                    network=str(getattr(active_backend, "network", "unknown")),
+                    summary=policy_summary,
+                    require_mainnet_confirmation=bool(config.allow_mainnet),
+                )
+                require_single_use(approval_token.strip())
+                status = autonomous_session.start_session(config)
+                return AgentToolResult(tool=tool_name, ok=True, data=status)
+
             if tool_name == "x402_search_services":
                 query = args.get("query")
                 discovery_provider = args.get("discovery_provider", "auto")
@@ -4368,16 +4863,26 @@ 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),
+                    )
+                    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."
+                        )
+                    approval_summary_copy = dict(approval_summary)
+                else:
+                    approval_token, approval_summary_copy = await self._authorize_base_swap_permission(
+                        active_backend=active_backend,
+                        tool_name=tool_name,
+                        action_label="EVM swap",
+                        preview_kwargs=preview_kwargs,
+                        preview_method=active_backend.preview_evm_swap,
                     )
                 expected_summary = {
                     "operation": "EVM swap",
@@ -4387,12 +4892,11 @@ class OpenClawWalletAdapter:
                     "input_amount_raw": amount_in_raw.strip(),
                 }
                 for key, expected_value in expected_summary.items():
-                    if approval_summary.get(key) != expected_value:
+                    if approval_summary_copy.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)
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
@@ -4674,16 +5178,26 @@ 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),
+                    )
+                    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."
+                        )
+                    approval_summary_copy = dict(approval_summary)
+                else:
+                    approval_token, approval_summary_copy = await self._authorize_base_swap_permission(
+                        active_backend=active_backend,
+                        tool_name=tool_name,
+                        action_label="Uniswap swap",
+                        preview_kwargs=preview_kwargs,
+                        preview_method=active_backend.preview_uniswap_swap,
                     )
                 expected_summary = {
                     "operation": "Uniswap swap",
@@ -4693,12 +5207,11 @@ class OpenClawWalletAdapter:
                     "input_amount_raw": amount_in_raw.strip(),
                 }
                 for key, expected_value in expected_summary.items():
-                    if approval_summary.get(key) != expected_value:
+                    if approval_summary_copy.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)
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
@@ -5480,6 +5993,7 @@ class OpenClawWalletAdapter:
                 purpose = args.get("purpose")
                 user_intent = args.get("user_intent", False)
                 approval_token = args.get("approval_token")
+                valid_for_seconds = args.get("valid_for_seconds", 120)
 
                 if not isinstance(market, str) or not market.strip():
                     raise WalletBackendError("market is required.")
@@ -5489,10 +6003,18 @@ class OpenClawWalletAdapter:
                     raise WalletBackendError("amount_ui is required.")
                 if obligation_address is not None and not isinstance(obligation_address, str):
                     raise WalletBackendError("obligation_address must be a string when provided.")
-                if mode not in {"preview", "prepare", "execute"}:
-                    raise WalletBackendError("mode must be 'preview', 'prepare' or 'execute'.")
+                if mode not in {"preview", "prepare", "execute", "intent_preview", "intent_execute"}:
+                    raise WalletBackendError(
+                        "mode must be 'preview', 'prepare', 'execute', 'intent_preview' or 'intent_execute'."
+                    )
                 if not isinstance(purpose, str) or not purpose.strip():
                     raise WalletBackendError("purpose is required.")
+                if mode == "intent_preview" and (
+                    not isinstance(valid_for_seconds, int)
+                    or valid_for_seconds <= 0
+                    or valid_for_seconds > 300
+                ):
+                    raise WalletBackendError("valid_for_seconds must be an integer between 1 and 300.")
 
                 action_label_map = {
                     "kamino_lend_deposit": "Kamino deposit",
@@ -5500,12 +6022,24 @@ class OpenClawWalletAdapter:
                     "kamino_lend_borrow": "Kamino borrow",
                     "kamino_lend_repay": "Kamino repay",
                 }
+                intent_action_label_map = {
+                    "kamino_lend_deposit": "Kamino deposit intent",
+                    "kamino_lend_withdraw": "Kamino withdraw intent",
+                    "kamino_lend_borrow": "Kamino borrow intent",
+                    "kamino_lend_repay": "Kamino repay intent",
+                }
                 preview_method_map = {
                     "kamino_lend_deposit": self.backend.preview_kamino_lend_deposit,
                     "kamino_lend_withdraw": self.backend.preview_kamino_lend_withdraw,
                     "kamino_lend_borrow": self.backend.preview_kamino_lend_borrow,
                     "kamino_lend_repay": self.backend.preview_kamino_lend_repay,
                 }
+                intent_preview_method_map = {
+                    "kamino_lend_deposit": self.backend.preview_kamino_lend_deposit_intent,
+                    "kamino_lend_withdraw": self.backend.preview_kamino_lend_withdraw_intent,
+                    "kamino_lend_borrow": self.backend.preview_kamino_lend_borrow_intent,
+                    "kamino_lend_repay": self.backend.preview_kamino_lend_repay_intent,
+                }
                 execute_method_map = {
                     "kamino_lend_deposit": self.backend.execute_kamino_lend_deposit,
                     "kamino_lend_withdraw": self.backend.execute_kamino_lend_withdraw,
@@ -5513,8 +6047,113 @@ class OpenClawWalletAdapter:
                     "kamino_lend_repay": self.backend.execute_kamino_lend_repay,
                 }
                 action_label = action_label_map[tool_name]
+                intent_action_label = intent_action_label_map[tool_name]
                 preview_method = preview_method_map[tool_name]
+                intent_preview_method = intent_preview_method_map[tool_name]
                 execute_method = execute_method_map[tool_name]
+                normalized_obligation_address = (
+                    obligation_address.strip()
+                    if isinstance(obligation_address, str) and obligation_address.strip()
+                    else None
+                )
+
+                if mode == "intent_preview":
+                    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,
+                    )
+                    if bool(intent_preview.get("requires_obligation_address")):
+                        raise WalletBackendError(
+                            f"{action_label} requires obligation_address when multiple Kamino obligations match the selected position."
+                        )
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data=self._annotate_sensitive_payload(
+                            intent_preview,
+                            action_label=intent_action_label,
+                            mode="preview",
+                        ),
+                    )
+
+                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."
+                        )
+                    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)
+                    self._require_execute_approval(
+                        approval_token=approval_token,
+                        tool_name=tool_name,
+                        summary=approval_summary_copy,
+                        action_label=intent_action_label,
+                    )
+                    result = await execute_method(
+                        market=market.strip(),
+                        reserve=reserve.strip(),
+                        amount_ui=amount_ui.strip(),
+                        obligation_address=(
+                            str(approved_obligation).strip()
+                            if approved_obligation
+                            else normalized_obligation_address
+                        ),
+                        approved_preview=None,
+                    )
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data=self._annotate_sensitive_payload(
+                            result,
+                            action_label=action_label,
+                            mode="execute",
+                        ),
+                    )
 
                 if mode == "preview":
                     preview = await preview_method(