@agentlayer.tech/wallet 0.1.94 → 0.1.96

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -11,6 +11,13 @@ 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.networks import (
+    EVM_CORE_MAINNET_CAIP_IDS,
+    EVM_CORE_MAINNETS,
+    EVM_CORE_NETWORK_ALIASES,
+    EVM_CORE_TESTNETS,
+    GOAT_EVM_NETWORK_IDENTIFIERS,
+)
 from agent_wallet.providers import x402
 from agent_wallet.wallet_layer.base import AgentWalletBackend, WalletBackendError
 
@@ -74,7 +81,7 @@ class OpenClawWalletAdapter:
         if chain == "bitcoin":
             return normalized == "bitcoin"
         if chain == "evm":
-            return normalized in {"ethereum", "base", "robinhood", "eip155:1", "eip155:8453", "eip155:4663"}
+            return normalized in EVM_CORE_MAINNETS | EVM_CORE_MAINNET_CAIP_IDS
         if chain == "solana":
             return normalized in {"mainnet", "solana:5eykt4usfv8p8njdtrepy1vzkqzkvdp"}
         return normalized == "mainnet"
@@ -85,6 +92,10 @@ class OpenClawWalletAdapter:
     def _is_mainnet_for_backend(self, backend: AgentWalletBackend) -> bool:
         return self._is_mainnet_network(getattr(backend, "network", ""))
 
+    @staticmethod
+    def _is_goat_evm_network(network: Any) -> bool:
+        return str(network or "").strip().lower() in GOAT_EVM_NETWORK_IDENTIFIERS
+
     def _supports_evm_velora(self) -> bool:
         return str(getattr(self.backend, "chain", "")).strip().lower() == "evm" and self._is_mainnet()
 
@@ -93,17 +104,13 @@ class OpenClawWalletAdapter:
 
     def _normalize_evm_tool_network(self, value: Any) -> str:
         network = str(value or "").strip().lower()
-        aliases = {
-            "mainnet": "ethereum",
-            "eth": "ethereum",
-            "eth-mainnet": "ethereum",
-            "base-mainnet": "base",
-        }
-        network = aliases.get(network, network)
-        if network in {"sepolia", "base-sepolia", "base_sepolia"}:
-            raise WalletBackendError("EVM testnets are no longer supported. Use ethereum, base, or robinhood.")
-        if network not in {"ethereum", "base", "robinhood"}:
-            raise WalletBackendError("EVM network must be 'ethereum', 'base', or 'robinhood'.")
+        network = EVM_CORE_NETWORK_ALIASES.get(network, network)
+        if network in EVM_CORE_TESTNETS:
+            raise WalletBackendError(
+                "EVM testnets are no longer supported. Use ethereum, base, robinhood, or goat."
+            )
+        if network not in EVM_CORE_MAINNETS:
+            raise WalletBackendError("EVM network must be 'ethereum', 'base', 'robinhood', or 'goat'.")
         return network
 
     def _resolve_backend_for_args(self, args: dict[str, Any]) -> AgentWalletBackend:
@@ -1229,7 +1236,7 @@ class OpenClawWalletAdapter:
                         "properties": {
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1246,7 +1253,7 @@ class OpenClawWalletAdapter:
                         "properties": {
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1271,7 +1278,7 @@ class OpenClawWalletAdapter:
                             },
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1352,7 +1359,7 @@ class OpenClawWalletAdapter:
                         "properties": {
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1365,7 +1372,7 @@ class OpenClawWalletAdapter:
                     name="set_evm_network",
                     description=(
                         "Select the active EVM network for subsequent wallet tool calls in this "
-                        "runtime session. Use this to switch between ethereum, base, and robinhood instead "
+                        "runtime session. Use this to switch between ethereum, base, robinhood, and goat instead "
                         "of editing code or plugin configuration."
                     ),
                     input_schema={
@@ -1373,7 +1380,7 @@ class OpenClawWalletAdapter:
                         "properties": {
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "EVM network to make active for subsequent calls.",
                             },
                         },
@@ -1395,7 +1402,7 @@ class OpenClawWalletAdapter:
                             },
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1417,7 +1424,7 @@ class OpenClawWalletAdapter:
                             },
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1435,7 +1442,7 @@ class OpenClawWalletAdapter:
                         "properties": {
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1446,7 +1453,10 @@ class OpenClawWalletAdapter:
                 ),
                 AgentToolSpec(
                     name="get_evm_transaction_receipt",
-                    description="Get the transaction receipt for a broadcast EVM transaction hash.",
+                    description=(
+                        "Get the transaction receipt for a broadcast EVM transaction hash. On GOAT, a receipt "
+                        "confirms L2 inclusion; it does not by itself prove Bitcoin-backed finality."
+                    ),
                     input_schema={
                         "type": "object",
                         "properties": {
@@ -1456,7 +1466,7 @@ class OpenClawWalletAdapter:
                             },
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1489,7 +1499,7 @@ class OpenClawWalletAdapter:
                             "approval_token": {"type": "string"},
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1524,7 +1534,7 @@ class OpenClawWalletAdapter:
                             "approval_token": {"type": "string"},
                             "network": {
                                 "type": "string",
-                                "enum": ["ethereum", "base", "robinhood"],
+                                "enum": ["ethereum", "base", "robinhood", "goat"],
                                 "description": "Optional EVM network override for this request.",
                             },
                         },
@@ -1746,12 +1756,62 @@ class OpenClawWalletAdapter:
                 )
                 tools.insert(
                     13,
+                    AgentToolSpec(
+                        name="get_evm_uniswap_pools",
+                        description=(
+                            "Find existing Uniswap V3/V4 pool metadata on ethereum, base, or robinhood using the official "
+                            "Uniswap Pool Info API. Returns the canonical poolReferenceIdentifier required to create liquidity; "
+                            "this is read-only and does not approve, sign, or execute anything."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "protocol": {"type": "string", "enum": ["V3", "V4"]},
+                                "pool_parameters": {"type": "object", "description": "Official Pool Info API token-pair parameters, such as tokenAddressA, tokenAddressB and optional fee/tickSpacing/hooks.", "additionalProperties": True},
+                                "pool_references": {"type": "array", "maxItems": 20, "items": {"type": "object", "additionalProperties": True}, "description": "One to twenty official Pool Info API pool reference objects."},
+                                "page_size": {"type": "integer", "minimum": 1, "maximum": 20},
+                                "current_page": {"type": "integer", "minimum": 1},
+                                "network": {"type": "string", "enum": ["ethereum", "base", "robinhood"]},
+                            },
+                            "required": ["protocol"],
+                            "additionalProperties": False,
+                        },
+                        read_only=True,
+                        risk_level="low",
+                    ),
+                )
+                tools.insert(
+                    14,
+                    AgentToolSpec(
+                        name="get_evm_uniswap_positions",
+                        description=(
+                            "List read-only Uniswap V3 LP position NFTs owned by the active wallet on ethereum, base, or robinhood. "
+                            "Returns NFT token ids, tokens, fee tier, tick range, liquidity, and currently owed fees. V4 discovery is "
+                            "not exposed until a verified indexed source is configured because V4 PositionManager is not enumerable."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "protocol": {"type": "string", "enum": ["V3"], "description": "V3 is the currently enumerable, on-chain-supported position scanner."},
+                                "limit": {"type": "integer", "minimum": 1, "maximum": 100},
+                                "network": {"type": "string", "enum": ["ethereum", "base", "robinhood"]},
+                            },
+                            "additionalProperties": False,
+                        },
+                        read_only=True,
+                        risk_level="low",
+                    ),
+                )
+                tools.insert(
+                    15,
                     AgentToolSpec(
                         name="manage_evm_uniswap_liquidity",
                         description=(
                             "Preview, prepare, or execute a Uniswap V3/V4 liquidity action on ethereum, base, or robinhood. "
                             "Supported actions are create, increase, decrease, and claim_fees. The request is passed to the "
-                            "official Uniswap Liquidity API; execute refreshes the transaction immediately before signing."
+                            "official Uniswap Liquidity API; execute refreshes the transaction immediately before signing. "
+                            "Create requires existingPool.poolReference; increase/decrease/claim_fees require a position NFT token id. "
+                            "Use get_evm_uniswap_pools or get_evm_uniswap_positions to obtain these identifiers; never guess them."
                         ),
                         input_schema={
                             "type": "object",
@@ -4270,6 +4330,14 @@ class OpenClawWalletAdapter:
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
             if tool_name == "x402_pay_request":
+                if (
+                    str(getattr(active_backend, "chain", "")).strip().lower() == "evm"
+                    and self._is_goat_evm_network(getattr(active_backend, "network", ""))
+                ):
+                    raise WalletBackendError(
+                        "GOAT x402 payments are not enabled in this wallet surface. "
+                        "Use the supported core GOAT wallet operations instead."
+                    )
                 url = args.get("url")
                 method = args.get("method", "GET")
                 headers = args.get("headers")
@@ -5682,6 +5750,46 @@ class OpenClawWalletAdapter:
                 )
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
+            if tool_name == "get_evm_uniswap_pools":
+                protocol = args.get("protocol")
+                pool_parameters = args.get("pool_parameters")
+                pool_references = args.get("pool_references")
+                page_size = args.get("page_size", 20)
+                current_page = args.get("current_page", 1)
+                if protocol not in {"V3", "V4"}:
+                    raise WalletBackendError("protocol must be V3 or V4.")
+                if (pool_parameters is None) == (pool_references is None):
+                    raise WalletBackendError("Provide exactly one of pool_parameters or pool_references.")
+                if pool_parameters is not None and not isinstance(pool_parameters, dict):
+                    raise WalletBackendError("pool_parameters must be an object.")
+                if pool_references is not None:
+                    if not isinstance(pool_references, list) or not 1 <= len(pool_references) <= 20:
+                        raise WalletBackendError("pool_references must contain between 1 and 20 objects.")
+                    if any(not isinstance(reference, dict) for reference in pool_references):
+                        raise WalletBackendError("pool_references must contain only objects.")
+                if not isinstance(page_size, int) or not 1 <= page_size <= 20:
+                    raise WalletBackendError("page_size must be an integer between 1 and 20.")
+                if not isinstance(current_page, int) or current_page < 1:
+                    raise WalletBackendError("current_page must be a positive integer.")
+                data = await active_backend.get_uniswap_liquidity_pools(
+                    protocol=protocol,
+                    pool_parameters=pool_parameters,
+                    pool_references=pool_references,
+                    page_size=page_size,
+                    current_page=current_page,
+                )
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
+            if tool_name == "get_evm_uniswap_positions":
+                protocol = args.get("protocol", "V3")
+                limit = args.get("limit", 20)
+                if protocol != "V3":
+                    raise WalletBackendError("Only V3 position discovery is currently available; V4 PositionManager is not enumerable.")
+                if not isinstance(limit, int) or not 1 <= limit <= 100:
+                    raise WalletBackendError("limit must be an integer between 1 and 100.")
+                data = await active_backend.get_uniswap_liquidity_positions(protocol=protocol, 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")
@@ -5826,13 +5934,49 @@ class OpenClawWalletAdapter:
                     raise WalletBackendError("mode must be 'preview', 'prepare' or 'execute'.")
                 if not isinstance(purpose, str) or not purpose.strip():
                     raise WalletBackendError("purpose is required.")
+                normalized_request = dict(request)
+                if action == "create":
+                    existing_pool = normalized_request.get("existingPool")
+                    if not isinstance(existing_pool, dict):
+                        raise WalletBackendError(
+                            "create requires existingPool with token0Address, token1Address, and poolReference. "
+                            "Use get_evm_uniswap_pools to obtain the exact existing pool; do not infer it from market search data."
+                        )
+                    missing_pool_fields = [
+                        field
+                        for field in ("token0Address", "token1Address", "poolReference")
+                        if not isinstance(existing_pool.get(field), str) or not existing_pool[field].strip()
+                    ]
+                    if missing_pool_fields:
+                        raise WalletBackendError(
+                            "create existingPool is missing "
+                            f"{', '.join(missing_pool_fields)}. Ask the user for the exact existing Uniswap pool; do not infer it from market search data."
+                        )
+                elif action in {"increase", "decrease"}:
+                    nft_token_id = normalized_request.get("nftTokenId")
+                    if not isinstance(nft_token_id, str) or not nft_token_id.strip().isdigit() or int(nft_token_id.strip()) <= 0:
+                        raise WalletBackendError(
+                            f"{action} requires a positive nftTokenId. Use get_evm_uniswap_positions for V3 or request a verified V4 token id; never infer it."
+                        )
+                    normalized_request["nftTokenId"] = nft_token_id.strip()
+                else:  # claim_fees
+                    token_id = normalized_request.get("tokenId", normalized_request.get("nftTokenId"))
+                    if not isinstance(token_id, str) or not token_id.strip().isdigit() or int(token_id.strip()) <= 0:
+                        raise WalletBackendError(
+                            "claim_fees requires the user's positive tokenId (the LP position NFT id). "
+                            "Use get_evm_uniswap_positions for V3 or request a verified V4 token id; never infer it."
+                        )
+                    # The Liquidity API names this field tokenId for fee claims;
+                    # accept nftTokenId as the user-facing alias used by other LP actions.
+                    normalized_request["tokenId"] = token_id.strip()
+                    normalized_request.pop("nftTokenId", None)
                 # The caller must not override values that are derived from the
                 # active wallet/network in the WDK layer.
                 forbidden = {"walletAddress", "chainId", "protocol", "simulateTransaction", "signature", "batchPermitData", "v4BatchPermitData", "v3NftPermitData"}
                 overlap = forbidden.intersection(request)
                 if overlap:
                     raise WalletBackendError(f"request must not set wallet-controlled fields: {', '.join(sorted(overlap))}.")
-                preview_kwargs = {"action": action, "protocol": protocol, "request": dict(request)}
+                preview_kwargs = {"action": action, "protocol": protocol, "request": normalized_request}
                 if mode == "preview":
                     preview = await active_backend.preview_uniswap_liquidity(**preview_kwargs)
                     return AgentToolResult(tool=tool_name, ok=True, data=self._annotate_sensitive_payload(preview, action_label="Uniswap liquidity", mode="preview"))

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

@@ -117,6 +117,7 @@ TOKEN_METADATA: dict[str, dict[str, dict[str, Any]]] = {
 }
 
 COINGECKO_IDS = {
+    "BTC": "bitcoin",
     "ETH": "ethereum",
     "WETH": "ethereum",
     "USDC": "usd-coin",
@@ -142,7 +143,7 @@ _PRICE_CACHE: dict[str, tuple[float, float]] = {}
 
 def _normalize_network(network: str) -> str:
     normalized = str(network or "").strip().lower()
-    if normalized not in {"ethereum", "base", "robinhood"}:
+    if normalized not in {"ethereum", "base", "robinhood", "goat"}:
         raise ProviderError("evm-portfolio", f"Unsupported EVM portfolio network: {network}")
     return normalized
 
@@ -207,7 +208,7 @@ async def _gateway_rpc_call(network: str, method: str, params: list[Any]) -> dic
     if not gateway_url:
         raise ProviderError(
             "evm-portfolio",
-            "Provider gateway URL is required for EVM portfolio lookup on ethereum/base/robinhood.",
+            "Provider gateway URL is required for EVM portfolio lookup on supported EVM networks.",
         )
     try:
         response = await client.post(
@@ -230,6 +231,12 @@ async def _gateway_rpc_call(network: str, method: str, params: list[Any]) -> dic
 
 async def fetch_token_balances(address: str, network: str) -> list[dict[str, Any]]:
     normalized_network = _normalize_network(network)
+    # GOAT uses the shared RPC gateway rather than Alchemy. Its upstream does
+    # not provide Alchemy's account-wide ERC-20 index, so return a truthful
+    # native-only portfolio. Explicit per-token balance and metadata tools keep
+    # working through ordinary EVM RPC calls.
+    if normalized_network == "goat":
+        return []
     cache_key = f"{normalized_network}:{address.lower()}"
     cached = _cache_get_token_balances(cache_key)
     if cached is not None:

package/agent-wallet/agent_wallet/wallet_layer/base.py

@@ -337,6 +337,25 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Uniswap pair search.")
 
+    async def get_uniswap_liquidity_pools(
+        self,
+        *,
+        protocol: str,
+        pool_parameters: dict[str, Any] | None = None,
+        pool_references: list[dict[str, Any]] | None = None,
+        page_size: int = 20,
+        current_page: int = 1,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap liquidity pool discovery.")
+
+    async def get_uniswap_liquidity_positions(
+        self,
+        *,
+        protocol: str = "V3",
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap liquidity position discovery.")
+
     async def send_uniswap_swap(
         self,
         *,

package/agent-wallet/agent_wallet/wallet_layer/wdk_evm.py

@@ -668,7 +668,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "configured_network": self.network,
             "service_active_network": str(data.get("activeNetwork") or "").strip() or None,
             "available_networks": sorted(str(key) for key in profiles.keys()),
-            "agent_selectable_networks": ["ethereum", "base", "robinhood"],
+            "agent_selectable_networks": ["ethereum", "base", "robinhood", "goat"],
             "swap_supported_networks": ["ethereum", "base", "robinhood"],
             "network_profiles": {
                 str(network): {
@@ -1957,6 +1957,66 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "source": "dexscreener",
         }
 
+    async def get_uniswap_liquidity_pools(
+        self,
+        *,
+        protocol: str,
+        pool_parameters: dict[str, Any] | None = None,
+        pool_references: list[dict[str, Any]] | None = None,
+        page_size: int = 20,
+        current_page: int = 1,
+    ) -> dict[str, Any]:
+        if protocol not in {"V3", "V4"}:
+            raise WalletBackendError("protocol must be V3 or V4.")
+        if (pool_parameters is None) == (pool_references is None):
+            raise WalletBackendError("Provide exactly one of pool_parameters or pool_references.")
+        if pool_parameters is not None and not isinstance(pool_parameters, dict):
+            raise WalletBackendError("pool_parameters must be an object.")
+        if pool_references is not None:
+            if not isinstance(pool_references, list) or not 1 <= len(pool_references) <= 20:
+                raise WalletBackendError("pool_references must contain between 1 and 20 objects.")
+            if any(not isinstance(reference, dict) for reference in pool_references):
+                raise WalletBackendError("pool_references must contain only objects.")
+        if not isinstance(page_size, int) or not 1 <= page_size <= 20:
+            raise WalletBackendError("page_size must be an integer between 1 and 20.")
+        if not isinstance(current_page, int) or current_page < 1:
+            raise WalletBackendError("current_page must be a positive integer.")
+        body: dict[str, Any] = {
+            "network": self.network,
+            "protocol": protocol,
+            "pageSize": page_size,
+            "currentPage": current_page,
+        }
+        if pool_parameters is not None:
+            body["poolParameters"] = pool_parameters
+        else:
+            body["poolReferences"] = pool_references
+        data = await self.client.post("/v1/evm/uniswap/liquidity/pools", body)
+        return dict(data)
+
+    async def get_uniswap_liquidity_positions(
+        self,
+        *,
+        protocol: str = "V3",
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        if protocol not in {"V3", "V4"}:
+            raise WalletBackendError("protocol must be V3 or V4.")
+        if not isinstance(limit, int) or not 1 <= limit <= 100:
+            raise WalletBackendError("limit must be an integer between 1 and 100.")
+        data = await self.client.post(
+            "/v1/evm/uniswap/liquidity/positions",
+            {
+                "walletId": self.wallet_id,
+                "address": await self.get_address(),
+                "accountIndex": self.account_index,
+                "network": self.network,
+                "protocol": protocol,
+                "limit": limit,
+            },
+        )
+        return dict(data)
+
     async def send_uniswap_swap(
         self,
         *,

package/agent-wallet/openclaw.plugin.json

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

package/agent-wallet/pyproject.toml

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

package/agent-wallet/scripts/install_agent_wallet.py

@@ -513,6 +513,26 @@ def _pip_install_editable(python_bin: Path, package_root: Path) -> None:
     )
 
 
+def _python_runtime_is_healthy(python_bin: Path) -> bool:
+    """Return whether a reusable venv has the installer dependencies available.
+
+    A shared runtime can be left half-created when an install is interrupted
+    between ``venv`` creation and the editable pip install.  The interpreter
+    itself then exists, but the next update must repair it rather than treating
+    it as a valid cache entry.
+    """
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import pydantic, pydantic_settings"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except OSError:
+        return False
+    return result.returncode == 0
+
+
 def _ensure_python_runtime(
     venv_path: Path,
     package_root: Path,
@@ -529,9 +549,17 @@ def _ensure_python_runtime(
             created = True
             _bootstrap_venv_pip(python_bin)
             _pip_install_editable(python_bin, package_root)
+        elif not _python_runtime_is_healthy(python_bin):
+            # A prior update may have been interrupted after creating the venv
+            # but before pip finished. Repair the cache in place; release links
+            # continue to point at one verified shared environment.
+            _bootstrap_venv_pip(python_bin)
+            _pip_install_editable(python_bin, package_root)
+            plan["action"] = "repair"
         shared_wrapper = _ensure_python_wrapper(shared_venv_path)
         _replace_with_directory_symlink(venv_path, shared_venv_path)
-        plan["action"] = "create" if created else "reuse"
+        if created:
+            plan["action"] = "create"
         plan["exists"] = True
         return (
             venv_path / shared_wrapper.relative_to(shared_venv_path),

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

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