intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/skills/http/put.py

@@ -1,7 +1,8 @@
 import logging
-from typing import Any, Dict, Optional, Type, Union
+from typing import Any
 
 import httpx
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.skills.http.base import HttpBaseTool
@@ -13,19 +14,19 @@ class HttpPutInput(BaseModel):
     """Input for HTTP PUT request."""
 
     url: str = Field(description="The URL to send the PUT request to")
-    data: Optional[Union[Dict[str, Any], str]] = Field(
+    data: dict[str, Any] | str | None = Field(
         description="The data to send in the request body. Can be a dictionary (will be sent as JSON) or a string",
         default=None,
     )
-    headers: Optional[Dict[str, str]] = Field(
+    headers: dict[str, str] | None = Field(
         description="Optional headers to include in the request",
         default=None,
     )
-    params: Optional[Dict[str, Any]] = Field(
+    params: dict[str, Any] | None = Field(
         description="Optional query parameters to include in the request",
         default=None,
     )
-    timeout: Optional[float] = Field(
+    timeout: float | None = Field(
         description="Request timeout in seconds (default: 30)",
         default=30.0,
     )
@@ -51,14 +52,14 @@ class HttpPut(HttpBaseTool):
         "Returns the response content as text. "
         "Use this when you need to update or replace data on web APIs."
     )
-    args_schema: Type[BaseModel] = HttpPutInput
+    args_schema: type[BaseModel] = HttpPutInput
 
     async def _arun(
         self,
         url: str,
-        data: Optional[Union[Dict[str, Any], str]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        params: Optional[Dict[str, Any]] = None,
+        data: dict[str, Any] | str | None = None,
+        headers: dict[str, str] | None = None,
+        params: dict[str, Any] | None = None,
         timeout: float = 30.0,
         **kwargs,
     ) -> str:
@@ -100,12 +101,16 @@ class HttpPut(HttpBaseTool):
                 # Return response content
                 return f"Status: {response.status_code}\nContent: {response.text}"
 
-        except httpx.TimeoutException:
-            return f"Error: Request to {url} timed out after {timeout} seconds"
-        except httpx.HTTPStatusError as e:
-            return f"Error: HTTP {e.response.status_code} - {e.response.text}"
-        except httpx.RequestError as e:
-            return f"Error: Failed to connect to {url} - {str(e)}"
-        except Exception as e:
-            logger.error(f"Unexpected error in HTTP PUT request: {e}")
-            return f"Error: Unexpected error occurred - {str(e)}"
+        except httpx.TimeoutException as exc:
+            raise ToolException(
+                f"Request to {url} timed out after {timeout} seconds"
+            ) from exc
+        except httpx.HTTPStatusError as exc:
+            raise ToolException(
+                f"HTTP {exc.response.status_code} - {exc.response.text}"
+            ) from exc
+        except httpx.RequestError as exc:
+            raise ToolException(f"Failed to connect to {url} - {str(exc)}") from exc
+        except Exception as exc:  # noqa: BLE001
+            logger.error("Unexpected error in HTTP PUT request", exc_info=exc)
+            raise ToolException(f"Unexpected error occurred - {str(exc)}") from exc

intentkit/skills/http/schema.json

@@ -5,10 +5,9 @@
   "description": "HTTP client skills for making web requests",
   "x-icon": "https://ai.service.crestal.dev/skills/http/http.svg",
   "x-tags": [
-    "HTTP",
-    "Web",
-    "API",
-    "Client"
+    "Developer Tools",
+    "Infrastructure",
+    "Knowledge Base"
   ],
   "properties": {
     "enabled": {
@@ -77,4 +76,4 @@
     "enabled"
   ],
   "additionalProperties": true
-}
+}

intentkit/skills/lifi/__init__.py

@@ -1,7 +1,6 @@
 import logging
-from typing import List, Optional, TypedDict
+from typing import Any, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.lifi.base import LiFiBaseTool
 from intentkit.skills.lifi.token_execute import TokenExecute
@@ -23,19 +22,18 @@ class Config(SkillConfig):
     """Configuration for LiFi skills."""
 
     states: SkillStates
-    default_slippage: Optional[float] = 0.03
-    allowed_chains: Optional[List[str]] = None
-    max_execution_time: Optional[int] = 300
+    default_slippage: float | None = 0.03
+    allowed_chains: list[str] | None = None
+    max_execution_time: int | None = 300
 
 
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
-    **_,
+    **_: Any,
 ) -> list[LiFiBaseTool]:
     """Get all LiFi skills."""
-    available_skills = []
+    available_skills: list[str] = []
 
     # Log configuration
     logger.info(f"[LiFi_Skills] Initializing with config: {config}")
@@ -57,10 +55,10 @@ async def get_skills(
     logger.info(f"[LiFi_Skills] Available skills: {available_skills}")
 
     # Get each skill using the cached getter
-    skills = []
+    skills: list[LiFiBaseTool] = []
     for name in available_skills:
         try:
-            skill = get_lifi_skill(name, store, config)
+            skill = get_lifi_skill(name, config)
             skills.append(skill)
             logger.info(f"[LiFi_Skills] Successfully loaded skill: {name}")
         except Exception as e:
@@ -73,7 +71,6 @@ async def get_skills(
 
 def get_lifi_skill(
     name: str,
-    store: SkillStoreABC,
     config: Config,
 ) -> LiFiBaseTool:
     """Get a LiFi skill by name."""
@@ -108,7 +105,6 @@ def get_lifi_skill(
                 logger.info(f"[LiFi_Skills] Allowed chains: {allowed_chains}")
 
             _cache[cache_key] = TokenQuote(
-                skill_store=store,
                 default_slippage=default_slippage,
                 allowed_chains=allowed_chains,
             )
@@ -129,7 +125,6 @@ def get_lifi_skill(
             )
 
             _cache[cache_key] = TokenExecute(
-                skill_store=store,
                 default_slippage=default_slippage,
                 allowed_chains=allowed_chains,
                 max_execution_time=max_execution_time,

intentkit/skills/lifi/base.py

@@ -1,20 +1,14 @@
-from typing import Type
-
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.onchain import IntentKitOnChainSkill
 
 
-class LiFiBaseTool(IntentKitSkill):
+class LiFiBaseTool(IntentKitOnChainSkill):
     """Base class for LiFi tools."""
 
     name: str = Field(description="The name of the tool")
     description: str = Field(description="A description of what the tool does")
-    args_schema: Type[BaseModel]
-    skill_store: SkillStoreABC = Field(
-        description="The skill store for persisting data"
-    )
+    args_schema: type[BaseModel]
 
     @property
     def category(self) -> str:

intentkit/skills/lifi/schema.json

@@ -5,10 +5,7 @@
   "description": "Cross-chain token transfer and swap capabilities using the LiFi protocol",
   "x-icon": "https://ai.service.crestal.dev/skills/lifi/lifi.png",
   "x-tags": [
-    "DeFi",
-    "Blockchain",
-    "Token Transfer",
-    "Cross-chain"
+    "DeFi"
   ],
   "properties": {
     "enabled": {
@@ -53,7 +50,10 @@
           "description": "Execute token transfers (requires CDP wallet and cdp skills enabled)"
         }
       },
-      "required": ["token_quote", "token_execute"],
+      "required": [
+        "token_quote",
+        "token_execute"
+      ],
       "description": "States for each LiFi skill"
     },
     "default_slippage": {
@@ -71,7 +71,13 @@
       "description": "List of blockchain networks that can be used (if empty, all supported chains are allowed)",
       "items": {
         "type": "string",
-        "examples": ["ETH", "POL", "ARB", "OPT", "DAI"]
+        "examples": [
+          "ETH",
+          "POL",
+          "ARB",
+          "OPT",
+          "DAI"
+        ]
       },
       "uniqueItems": true
     },
@@ -84,6 +90,9 @@
       "maximum": 1800
     }
   },
-  "required": ["states", "enabled"],
+  "required": [
+    "states",
+    "enabled"
+  ],
   "additionalProperties": true
-} 
+}

intentkit/skills/lifi/token_execute.py

@@ -1,12 +1,12 @@
 import asyncio
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 import httpx
+from cdp import EvmServerAccount, TransactionRequestEIP1559
 from pydantic import BaseModel, Field
 from web3 import Web3
+from web3.exceptions import TimeExhausted
 
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.clients import get_cdp_client
 from intentkit.skills.lifi.base import LiFiBaseTool
 from intentkit.skills.lifi.token_quote import TokenQuote
 from intentkit.skills.lifi.utils import (
@@ -22,6 +22,7 @@ from intentkit.skills.lifi.utils import (
     prepare_transaction_params,
     validate_inputs,
 )
+from intentkit.utils.error import IntentKitAPIError
 
 
 class TokenExecuteInput(BaseModel):
@@ -51,7 +52,7 @@ class TokenExecuteInput(BaseModel):
 class TokenExecute(LiFiBaseTool):
     """Tool for executing token transfers across chains using LiFi.
 
-    This tool executes actual token transfers and swaps using the CDP wallet provider.
+    This tool executes actual token transfers and swaps using the CDP EVM account.
     Requires a properly configured CDP wallet to work.
     """
 
@@ -62,37 +63,37 @@ class TokenExecute(LiFiBaseTool):
         "Use token_quote first to check rates and fees before executing.\n"
         "Supports all major chains like Ethereum, Polygon, Arbitrum, Optimism, Base, and more."
     )
-    args_schema: Type[BaseModel] = TokenExecuteInput
+    args_schema: type[BaseModel] = TokenExecuteInput
     api_url: str = LIFI_API_URL
 
     # Configuration options
     default_slippage: float = 0.03
-    allowed_chains: Optional[List[str]] = None
+    allowed_chains: list[str] | None = None
     max_execution_time: int = 300
-    quote_tool: TokenQuote = Field(default=None, exclude=True)
+    quote_tool: TokenQuote | None = Field(default=None, exclude=True)
 
     def __init__(
         self,
-        skill_store: SkillStoreABC,
         default_slippage: float = 0.03,
-        allowed_chains: Optional[List[str]] = None,
+        allowed_chains: list[str] | None = None,
         max_execution_time: int = 300,
-    ):
+    ) -> None:
         """Initialize the TokenExecute skill with configuration options."""
-        super().__init__(skill_store=skill_store)
+        super().__init__()
         self.default_slippage = default_slippage
         self.allowed_chains = allowed_chains
         self.max_execution_time = max_execution_time
         # Initialize quote tool if not set
         if not self.quote_tool:
             self.quote_tool = TokenQuote(
-                skill_store=skill_store,
                 default_slippage=default_slippage,
                 allowed_chains=allowed_chains,
             )
 
-    def _format_quote_result(self, data: Dict[str, Any]) -> str:
+    def _format_quote_result(self, data: dict[str, Any]) -> str:
         """Format the quote result in a readable format."""
+        if self.quote_tool is None:
+            raise RuntimeError("Quote tool is not initialized")
         # Use the same formatting as token_quote
         return self.quote_tool._format_quote_result(data)
 
@@ -103,7 +104,7 @@ class TokenExecute(LiFiBaseTool):
         from_token: str,
         to_token: str,
         from_amount: str,
-        slippage: float = None,
+        slippage: float | None = None,
         **kwargs,
     ) -> str:
         """Execute a token transfer."""
@@ -127,22 +128,36 @@ class TokenExecute(LiFiBaseTool):
 
             # Get agent context for CDP wallet
             context = self.get_context()
-            agent_id = context.agent_id
+            agent = context.agent
+            network_id = agent.network_id
+            if not network_id:
+                return "Agent network ID is not configured. Please set it before executing on-chain transactions."
+
+            try:
+                cdp_network = self.get_cdp_network()
+            except Exception as e:
+                self.logger.error("LiFi_CDP_Network_Error: %s", str(e))
+                return f"Invalid agent network for CDP: {str(e)}"
 
             self.logger.info(
                 f"Executing LiFi transfer: {from_amount} {from_token} on {from_chain} -> {to_token} on {to_chain}"
             )
 
-            # Get CDP wallet provider
-            cdp_wallet_provider = await self._get_cdp_wallet_provider(agent_id)
-            if isinstance(cdp_wallet_provider, str):  # Error message
-                return cdp_wallet_provider
+            # Get CDP EVM account and web3 client
+            evm_account = await self._get_evm_account()
+            if isinstance(evm_account, str):  # Error message
+                return evm_account
 
-            # Get wallet address
-            from_address = cdp_wallet_provider.get_address()
+            from_address = evm_account.address
             if not from_address:
                 return "No wallet address available. Please check your CDP wallet configuration."
 
+            try:
+                web3 = self.web3_client()
+            except Exception as e:
+                self.logger.error("LiFi_Web3_Error: %s", str(e))
+                return "Unable to initialize Web3 client. Please verify the agent's network configuration."
+
             # Get quote and execute transfer
             async with httpx.AsyncClient() as client:
                 # Step 1: Get quote
@@ -161,14 +176,22 @@ class TokenExecute(LiFiBaseTool):
 
                 # Step 2: Handle token approval if needed
                 approval_result = await self._handle_token_approval(
-                    cdp_wallet_provider, quote_data
+                    evm_account,
+                    quote_data,
+                    web3,
+                    cdp_network,
+                    from_address,
                 )
                 if approval_result:
                     self.logger.info(f"Token approval completed: {approval_result}")
 
                 # Step 3: Execute transaction
                 tx_hash = await self._execute_transfer_transaction(
-                    cdp_wallet_provider, quote_data
+                    evm_account,
+                    quote_data,
+                    from_address,
+                    cdp_network,
+                    web3,
                 )
 
                 # Step 4: Monitor status and return result
@@ -180,19 +203,18 @@ class TokenExecute(LiFiBaseTool):
             self.logger.error("LiFi_Error: %s", str(e))
             return f"An unexpected error occurred: {str(e)}"
 
-    async def _get_cdp_wallet_provider(self, agent_id: str):
-        """Get CDP wallet provider with error handling."""
+    async def _get_evm_account(self) -> EvmServerAccount | str:
+        """Get CDP EVM account with error handling."""
         try:
-            cdp_client = await get_cdp_client(agent_id, self.skill_store)
-            if not cdp_client:
-                return "CDP client not available. Please ensure your agent has CDP wallet configuration."
+            evm_account = await self.get_evm_account()
+            if not evm_account:
+                return "CDP wallet account not configured. Please set up your agent's CDP wallet first."
 
-            cdp_wallet_provider = await cdp_client.get_wallet_provider()
-            if not cdp_wallet_provider:
-                return "CDP wallet provider not configured. Please set up your agent's CDP wallet first."
-
-            return cdp_wallet_provider
+            return evm_account
 
+        except IntentKitAPIError as e:
+            self.logger.error("LiFi_CDP_Error: %s", str(e))
+            return f"Cannot access CDP wallet: {str(e)}\n\nPlease ensure your agent has a properly configured CDP wallet with sufficient funds."
         except Exception as e:
             self.logger.error("LiFi_CDP_Error: %s", str(e))
             return f"Cannot access CDP wallet: {str(e)}\n\nPlease ensure your agent has a properly configured CDP wallet with sufficient funds."
@@ -207,7 +229,7 @@ class TokenExecute(LiFiBaseTool):
         from_amount: str,
         slippage: float,
         from_address: str,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any] | str:
         """Get quote from LiFi API."""
         api_params = build_quote_params(
             from_chain,
@@ -249,8 +271,13 @@ class TokenExecute(LiFiBaseTool):
         return data
 
     async def _handle_token_approval(
-        self, wallet_provider, quote_data: Dict[str, Any]
-    ) -> Optional[str]:
+        self,
+        evm_account: EvmServerAccount,
+        quote_data: dict[str, Any],
+        web3: Web3,
+        network_id: str,
+        wallet_address: str,
+    ) -> str | None:
         """Handle ERC20 token approval if needed."""
         estimate = quote_data.get("estimate", {})
         approval_address = estimate.get("approvalAddress")
@@ -266,30 +293,44 @@ class TokenExecute(LiFiBaseTool):
 
         try:
             return await self._check_and_set_allowance(
-                wallet_provider, from_token_address, approval_address, from_amount
+                evm_account,
+                from_token_address,
+                approval_address,
+                from_amount,
+                web3,
+                network_id,
+                wallet_address,
             )
         except Exception as e:
             self.logger.error("LiFi_Token_Approval_Error: %s", str(e))
             raise Exception(f"Failed to approve token: {str(e)}")
 
     async def _execute_transfer_transaction(
-        self, wallet_provider, quote_data: Dict[str, Any]
+        self,
+        evm_account: EvmServerAccount,
+        quote_data: dict[str, Any],
+        from_address: str,
+        network_id: str,
+        web3: Web3,
     ) -> str:
         """Execute the main transfer transaction."""
         transaction_request = quote_data.get("transactionRequest")
 
         try:
-            tx_params = prepare_transaction_params(transaction_request)
+            tx_params = prepare_transaction_params(
+                transaction_request, wallet_address=from_address
+            )
+            tx_request = self._build_transaction_request(tx_params)
             self.logger.info(
-                f"Sending transaction to {tx_params['to']} with value {tx_params['value']}"
+                f"Sending transaction to {tx_params['to']} with value {tx_params.get('value', 0)}"
             )
 
             # Send transaction
-            tx_hash = wallet_provider.send_transaction(tx_params)
+            tx_hash = await evm_account.send_transaction(tx_request, network=network_id)
 
             # Wait for confirmation
-            receipt = wallet_provider.wait_for_transaction_receipt(tx_hash)
-            if not receipt or receipt.get("status") == 0:
+            receipt = await self._wait_for_receipt(web3, tx_hash)
+            if not receipt or receipt.get("status") != 1:
                 raise Exception(f"Transaction failed: {tx_hash}")
 
             return tx_hash
@@ -298,13 +339,59 @@ class TokenExecute(LiFiBaseTool):
             self.logger.error("LiFi_Execution_Error: %s", str(e))
             raise Exception(f"Failed to execute transaction: {str(e)}")
 
+    def _build_transaction_request(
+        self, tx_params: dict[str, Any]
+    ) -> TransactionRequestEIP1559:
+        """Convert prepared transaction parameters to an EIP-1559 request."""
+        request_kwargs: dict[str, Any] = {
+            "to": Web3.to_checksum_address(tx_params["to"]),
+            "data": tx_params.get("data", "0x"),
+        }
+
+        for key in ("value", "gas", "maxPriorityFeePerGas", "nonce", "chainId"):
+            value = tx_params.get(key)
+            if value is not None:
+                request_kwargs[key] = value
+
+        max_fee_per_gas = tx_params.get("maxFeePerGas") or tx_params.get("gasPrice")
+        if max_fee_per_gas is not None:
+            request_kwargs["maxFeePerGas"] = max_fee_per_gas
+
+        return TransactionRequestEIP1559(**request_kwargs)
+
+    async def _wait_for_receipt(
+        self, web3: Web3, tx_hash: str
+    ) -> dict[str, Any] | None:
+        """Wait for a transaction receipt using Web3 in a non-blocking way."""
+
+        try:
+            receipt = await asyncio.to_thread(
+                web3.eth.wait_for_transaction_receipt, tx_hash
+            )
+        except TimeExhausted as exc:
+            self.logger.error("LiFi_Execution_Error: %s", str(exc))
+            raise Exception(
+                f"Transaction not confirmed before timeout: {tx_hash}"
+            ) from exc
+        except Exception as exc:
+            self.logger.error("LiFi_Execution_Error: %s", str(exc))
+            raise
+
+        if receipt is None:
+            return None
+
+        if isinstance(receipt, dict):
+            return receipt
+
+        return dict(receipt)
+
     async def _finalize_transfer(
         self,
         client: httpx.AsyncClient,
         tx_hash: str,
         from_chain: str,
         to_chain: str,
-        quote_data: Dict[str, Any],
+        quote_data: dict[str, Any],
     ) -> str:
         """Finalize transfer and return formatted result."""
         self.logger.info(f"Transaction sent: {tx_hash}")
@@ -407,25 +494,27 @@ class TokenExecute(LiFiBaseTool):
 
     async def _check_and_set_allowance(
         self,
-        wallet_provider,
+        evm_account: EvmServerAccount,
         token_address: str,
         approval_address: str,
         amount: str,
-    ) -> Optional[str]:
+        web3: Web3,
+        network_id: str,
+        wallet_address: str,
+    ) -> str | None:
         """Check if token allowance is sufficient and set approval if needed."""
         try:
             # Normalize addresses
             token_address = Web3.to_checksum_address(token_address)
             approval_address = Web3.to_checksum_address(approval_address)
-            wallet_address = wallet_provider.get_address()
+            wallet_checksum = Web3.to_checksum_address(wallet_address)
+
+            contract = web3.eth.contract(address=token_address, abi=ERC20_ABI)
 
             # Check current allowance
             try:
-                current_allowance = wallet_provider.read_contract(
-                    contract_address=token_address,
-                    abi=ERC20_ABI,
-                    function_name="allowance",
-                    args=[wallet_address, approval_address],
+                current_allowance = await asyncio.to_thread(
+                    contract.functions.allowance(wallet_checksum, approval_address).call
                 )
 
                 required_amount = int(amount)
@@ -447,20 +536,21 @@ class TokenExecute(LiFiBaseTool):
 
             # Create approval transaction
             approve_data = create_erc20_approve_data(approval_address, amount)
+            approval_request = TransactionRequestEIP1559(
+                to=token_address,
+                data=approve_data,
+                value=0,
+            )
 
             # Send approval transaction
-            approval_tx_hash = wallet_provider.send_transaction(
-                {
-                    "to": token_address,
-                    "data": approve_data,
-                    "value": 0,
-                }
+            approval_tx_hash = await evm_account.send_transaction(
+                approval_request, network=network_id
             )
 
             # Wait for approval transaction confirmation
-            receipt = wallet_provider.wait_for_transaction_receipt(approval_tx_hash)
+            receipt = await self._wait_for_receipt(web3, approval_tx_hash)
 
-            if not receipt or receipt.get("status") == 0:
+            if not receipt or receipt.get("status") != 1:
                 raise Exception(f"Approval transaction failed: {approval_tx_hash}")
 
             return approval_tx_hash