intentkit 0.6.0.dev6__tar.gz → 0.6.0.dev7__tar.gz

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.0.dev6
+Version: 0.6.0.dev7
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.0-dev.6"
+__version__ = "0.6.0-dev.7"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit-0.6.0.dev7/clients/cdp.py

@@ -0,0 +1,105 @@
+import json
+import logging
+import os
+from typing import Dict, Optional
+
+from cdp import EvmServerAccount
+from coinbase_agentkit import (
+    CdpEvmServerWalletProvider,
+    CdpEvmServerWalletProviderConfig,
+)
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData
+
+_clients: Dict[str, "CdpClient"] = {}
+
+
+class CdpClient:
+    def __init__(self, agent_id: str, skill_store: SkillStoreABC) -> None:
+        self._agent_id = agent_id
+        self._skill_store = skill_store
+        self._wallet_provider: Optional[CdpEvmServerWalletProvider] = None
+        self._wallet_provider_config: Optional[CdpEvmServerWalletProviderConfig] = None
+
+    async def get_wallet_provider(self) -> CdpEvmServerWalletProvider:
+        if self._wallet_provider:
+            return self._wallet_provider
+        agent: Agent = await self._skill_store.get_agent_config(self._agent_id)
+        agent_data: AgentData = await self._skill_store.get_agent_data(self._agent_id)
+        network_id = agent.network_id or agent.cdp_network_id
+
+        logger = logging.getLogger(__name__)
+
+        # Collect credentials from system-config first, then env vars as fallback
+        api_key_id = (
+            self._skill_store.get_system_config("cdp_api_key_name")
+            or os.getenv("CDP_API_KEY_ID")
+            or os.getenv("CDP_API_KEY_NAME")
+        )
+
+        api_key_secret = (
+            self._skill_store.get_system_config("cdp_api_key_private_key")
+            or os.getenv("CDP_API_KEY_SECRET")
+            or os.getenv("CDP_API_KEY_PRIVATE_KEY")
+        )
+
+        wallet_secret = self._skill_store.get_system_config(
+            "cdp_wallet_secret"
+        ) or os.getenv("CDP_WALLET_SECRET")
+
+        address = None
+
+        # Attempt to override with any wallet-specific secret stored in wallet_data
+        if agent_data.cdp_wallet_data:
+            try:
+                wallet_data = json.loads(agent_data.cdp_wallet_data)
+                # Try to get address from the new format or fallback to old format
+                if "default_address_id" in wallet_data:
+                    address = wallet_data["default_address_id"]
+
+                # Prefer wallet_secret stored alongside the wallet data if present
+                if "wallet_secret" in wallet_data:
+                    wallet_secret = wallet_data["wallet_secret"]
+                elif "account_data" in wallet_data and wallet_data["account_data"]:
+                    # Some versions may nest the secret inside account_data
+                    wallet_secret = (
+                        wallet_data["account_data"].get("wallet_secret")
+                        or wallet_secret
+                    )
+            except json.JSONDecodeError:
+                logger.warning(
+                    "Invalid JSON in cdp_wallet_data for agent %s", self._agent_id
+                )
+
+        self._wallet_provider_config = CdpEvmServerWalletProviderConfig(
+            api_key_id=api_key_id,
+            api_key_secret=api_key_secret,
+            network_id=network_id,
+            address=address,
+            wallet_secret=wallet_secret,
+        )
+        self._wallet_provider = CdpEvmServerWalletProvider(self._wallet_provider_config)
+        return self._wallet_provider
+
+    async def get_account(self) -> EvmServerAccount:
+        """Get the account object from the wallet provider.
+
+        Returns:
+            EvmServerAccount: The account object that can be used for balance checks, transfers, etc.
+        """
+        wallet_provider = await self.get_wallet_provider()
+        # Access the internal account object
+        return wallet_provider._account
+
+    async def get_provider_config(self) -> CdpEvmServerWalletProviderConfig:
+        if not self._wallet_provider_config:
+            await self.get_wallet_provider()
+        return self._wallet_provider_config
+
+
+async def get_cdp_client(agent_id: str, skill_store: SkillStoreABC) -> "CdpClient":
+    if agent_id not in _clients:
+        _clients[agent_id] = CdpClient(agent_id, skill_store)
+    return _clients[agent_id]

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.0-dev.6"
+version = "0.6.0-dev.7"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/skills/cdp/__init__.py

@@ -5,10 +5,9 @@ from typing import TypedDict
 from coinbase_agentkit import (
     AgentKit,
     AgentKitConfig,
-    CdpWalletProvider,
+    CdpEvmServerWalletProvider,
     basename_action_provider,
     cdp_api_action_provider,
-    cdp_wallet_action_provider,
     erc20_action_provider,
     morpho_action_provider,
     pyth_action_provider,
@@ -37,10 +36,6 @@ class SkillStates(TypedDict):
     WalletActionProvider_native_transfer: SkillState
     CdpApiActionProvider_address_reputation: SkillState
     CdpApiActionProvider_request_faucet_funds: SkillState
-    CdpWalletActionProvider_deploy_contract: SkillState
-    CdpWalletActionProvider_deploy_nft: SkillState
-    CdpWalletActionProvider_deploy_token: SkillState
-    CdpWalletActionProvider_trade: SkillState
     PythActionProvider_fetch_price: SkillState
     PythActionProvider_fetch_price_feed_id: SkillState
     BasenameActionProvider_register_basename: SkillState
@@ -97,15 +92,15 @@ async def get_skills(
 
     # Initialize CDP client
     cdp_client: CdpClient = await get_cdp_client(agent_id, store)
-    cdp_wallet_provider: CdpWalletProvider = await cdp_client.get_wallet_provider()
-    cdp_provider_config = await cdp_client.get_provider_config()
+    cdp_wallet_provider: CdpEvmServerWalletProvider = (
+        await cdp_client.get_wallet_provider()
+    )
     agent_kit = AgentKit(
         AgentKitConfig(
             wallet_provider=cdp_wallet_provider,
             action_providers=[
                 wallet_action_provider(),
-                cdp_api_action_provider(cdp_provider_config),
-                cdp_wallet_action_provider(cdp_provider_config),
+                cdp_api_action_provider(),
                 pyth_action_provider(),
                 basename_action_provider(),
                 erc20_action_provider(),
@@ -121,9 +116,11 @@ async def get_skills(
     tools = []
     for skill in available_skills:
         if skill == "get_balance":
+            # Get the account object for the custom GetBalance skill
+            account = await cdp_client.get_account()
             tools.append(
                 GetBalance(
-                    wallet=cdp_wallet_provider._wallet,
+                    account=account,
                     agent_id=agent_id,
                     skill_store=store,
                 )

intentkit-0.6.0.dev7/skills/cdp/get_balance.py

@@ -0,0 +1,109 @@
+from typing import Type
+
+from cdp import EvmServerAccount
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.clients import get_cdp_client
+from intentkit.skills.cdp.base import CDPBaseTool
+
+
+class GetBalanceInput(BaseModel):
+    """Input for GetBalance tool."""
+
+    asset_id: str = Field(
+        description="The asset ID to get the balance for (e.g., 'eth', 'usdc', or a valid contract address)"
+    )
+
+
+class GetBalance(CDPBaseTool):
+    """Tool for getting balance from CDP wallet.
+
+    This tool uses the CDP API to get balance for all addresses in a wallet for a given asset.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    agent_id: str
+    skill_store: SkillStoreABC
+    account: EvmServerAccount | None = None
+
+    name: str = "cdp_get_balance"
+    description: str = (
+        "This tool will get the balance of all the addresses in the wallet for a given asset. It takes the asset ID as input."
+        "Always use 'eth' for the native asset ETH and 'usdc' for USDC. "
+        "Other valid asset IDs are: weth,dai,reth,brett,w,cbeth,axl,iotx,prime,aero,rsr,mog,tbtc,npc,yfi"
+    )
+    args_schema: Type[BaseModel] = GetBalanceInput
+
+    async def _arun(self, asset_id: str) -> str:
+        """Async implementation of the tool to get balance.
+
+        Args:
+            asset_id (str): The asset ID to get the balance for.
+
+        Returns:
+            str: A message containing the balance information or error message.
+        """
+        try:
+            if not self.account:
+                return "Failed to get account."
+
+            # Get network information from CDP client
+            cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
+            provider_config = await cdp_client.get_provider_config()
+            network_id = provider_config.network_id
+
+            # Map network_id to the format expected by the API
+            network_mapping = {
+                "base-mainnet": "base",
+                "base-sepolia": "base-sepolia",
+                "ethereum": "ethereum",
+                "ethereum-mainnet": "ethereum",
+            }
+            api_network = network_mapping.get(network_id, network_id)
+
+            # For native ETH balance, use the account's balance directly
+            if asset_id.lower() == "eth":
+                try:
+                    # Get native balance using Web3
+                    balance_wei = await self.account.get_balance()
+                    balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
+                    return f"ETH balance for account {self.account.address}: {balance_eth} ETH"
+                except Exception as e:
+                    return f"Error getting ETH balance: {e!s}"
+
+            # For other tokens, try the list_token_balances API
+            try:
+                # list_token_balances returns all token balances for the account
+                token_balances = await self.account.list_token_balances(api_network)
+
+                # Find the balance for the specific asset
+                target_balance = None
+                for balance in token_balances:
+                    if balance.asset_id.lower() == asset_id.lower():
+                        target_balance = balance
+                        break
+
+                if target_balance:
+                    return f"Balance for {asset_id} in account {self.account.address}: {target_balance.amount} {target_balance.asset_id}"
+                else:
+                    return f"No balance found for asset {asset_id} in account {self.account.address}"
+
+            except Exception as e:
+                return f"Error getting balance for account: {e!s}"
+
+        except Exception as e:
+            return f"Error getting balance: {str(e)}"
+
+    def _run(self, asset_id: str) -> str:
+        """Sync implementation of the tool.
+
+        This method is deprecated since we now have native async implementation in _arun.
+        """
+        raise NotImplementedError(
+            "Use _arun instead, which is the async implementation"
+        )

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/skills/cdp/schema.json

@@ -193,70 +193,6 @@
           "description": "State for WalletActionProvider_native_transfer",
           "default": "private"
         },
-        "CdpWalletActionProvider_trade": {
-          "type": "string",
-          "title": "CDP Wallet Trade",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_trade",
-          "default": "private"
-        },
-        "CdpWalletActionProvider_deploy_nft": {
-          "type": "string",
-          "title": "Cdp Wallet Deploy Nft",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_deploy_nft",
-          "default": "disabled"
-        },
-        "CdpWalletActionProvider_deploy_token": {
-          "type": "string",
-          "title": "CDP Wallet Deploy Token",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_deploy_token",
-          "default": "disabled"
-        },
-        "CdpWalletActionProvider_deploy_contract": {
-          "type": "string",
-          "title": "CDP Wallet Deploy Contract",
-          "enum": [
-            "disabled",
-            "public",
-            "private"
-          ],
-          "x-enum-title": [
-            "Disabled",
-            "Agent Owner + All Users",
-            "Agent Owner Only"
-          ],
-          "description": "State for CdpWalletActionProvider_deploy_contract",
-          "default": "disabled"
-        },
         "CdpApiActionProvider_request_faucet_funds": {
           "type": "string",
           "title": "CDP Request Faucet Funds",

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/skills/enso/base.py

@@ -1,6 +1,7 @@
 from typing import Optional, Type
 
-from cdp import Wallet
+from cdp import EvmServerAccount
+from coinbase_agentkit import CdpEvmServerWalletProvider
 from pydantic import BaseModel, Field
 
 from intentkit.abstracts.skill import SkillStoreABC
@@ -22,9 +23,31 @@ class EnsoBaseTool(IntentKitSkill):
         description="The skill store for persisting data"
     )
 
-    async def get_wallet(self, context: SkillContext) -> Optional[Wallet]:
+    async def get_account(self, context: SkillContext) -> Optional[EvmServerAccount]:
+        """Get the account object from the CDP client.
+
+        Args:
+            context: The skill context containing agent information.
+
+        Returns:
+            Optional[EvmServerAccount]: The account object if available.
+        """
+        client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
+        return await client.get_account()
+
+    async def get_wallet_provider(
+        self, context: SkillContext
+    ) -> Optional[CdpEvmServerWalletProvider]:
+        """Get the wallet provider from the CDP client.
+
+        Args:
+            context: The skill context containing agent information.
+
+        Returns:
+            Optional[CdpEvmServerWalletProvider]: The wallet provider if available.
+        """
         client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
-        return await client.get_wallet()
+        return await client.get_wallet_provider()
 
     def get_chain_provider(self, context: SkillContext) -> Optional[ChainProvider]:
         return self.skill_store.get_system_config("chain_provider")

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/skills/enso/route.py

@@ -6,9 +6,7 @@ from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.base import SkillContext
-from intentkit.skills.enso.abi.route import ABI_ROUTE
 from intentkit.skills.enso.networks import EnsoGetNetworks
-from intentkit.utils.tx import EvmContractWrapper
 
 from .base import EnsoBaseTool, base_url, default_chain_id
 
@@ -188,8 +186,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
         context: SkillContext = self.context_from_config(config)
         agent_id = context.agent.id
         api_token = self.get_api_token(context)
-        chain_provider = self.get_chain_provider(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
 
         async with httpx.AsyncClient() as client:
             try:
@@ -254,7 +251,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
                     tokenOut=tokenOut,
                 ).model_dump(exclude_none=True)
 
-                params["fromAddress"] = wallet.addresses[0].address_id
+                params["fromAddress"] = account.address
 
                 response = await client.get(url, headers=headers, params=params)
                 response.raise_for_status()  # Raise HTTPError for non-2xx responses
@@ -268,23 +265,27 @@ class EnsoRouteShortcut(EnsoBaseTool):
                 )
 
                 if broadcast_requested:
-                    rpc_url = chain_provider.get_chain_config_by_id(chainId).rpc_url
-                    contract = EvmContractWrapper(
-                        rpc_url, ABI_ROUTE, json_dict.get("tx")
-                    )
-
-                    fn, fn_args = contract.fn_and_args
-
-                    fn_args["amountIn"] = str(fn_args["amountIn"])
-
-                    invocation = wallet.invoke_contract(
-                        contract_address=contract.dst_addr,
-                        method=fn.fn_name,
-                        abi=ABI_ROUTE,
-                        args=fn_args,
-                    ).wait()
-
-                    res.txHash = invocation.transaction.transaction_hash
+                    # Use the wallet provider to send the transaction
+                    wallet_provider = await self.get_wallet_provider(context)
+
+                    # Extract transaction data from the Enso API response
+                    tx_data = json_dict.get("tx", {})
+                    if tx_data:
+                        # Send the transaction using the wallet provider
+                        tx_hash = wallet_provider.send_transaction(
+                            {
+                                "to": tx_data.get("to"),
+                                "data": tx_data.get("data", "0x"),
+                                "value": tx_data.get("value", 0),
+                            }
+                        )
+
+                        # Wait for transaction confirmation
+                        wallet_provider.wait_for_transaction_receipt(tx_hash)
+                        res.txHash = tx_hash
+                    else:
+                        # For now, return a placeholder transaction hash if no tx data
+                        res.txHash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
                 return res
 

{intentkit-0.6.0.dev6 → intentkit-0.6.0.dev7}/skills/enso/wallet.py

@@ -6,9 +6,7 @@ from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel, Field
 
 from intentkit.skills.base import SkillContext
-from intentkit.utils.tx import EvmContractWrapper
 
-from .abi.erc20 import ABI_ERC20
 from .base import EnsoBaseTool, base_url, default_chain_id
 
 
@@ -81,14 +79,14 @@ class EnsoGetWalletBalances(EnsoBaseTool):
 
         context: SkillContext = self.context_from_config(config)
         api_token = self.get_api_token(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
         params = EnsoGetBalancesInput(chainId=chainId).model_dump(exclude_none=True)
-        params["eoaAddress"] = wallet.addresses[0].address_id
+        params["eoaAddress"] = account.address
         params["useEoa"] = True
 
         async with httpx.AsyncClient() as client:
@@ -178,7 +176,7 @@ class EnsoGetWalletApprovals(EnsoBaseTool):
 
         context: SkillContext = self.context_from_config(config)
         api_token = self.get_api_token(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
 
         headers = {
             "accept": "application/json",
@@ -187,7 +185,7 @@ class EnsoGetWalletApprovals(EnsoBaseTool):
 
         params = EnsoGetApprovalsInput(
             chainId=chainId,
-            fromAddress=wallet.addresses[0].address_id,
+            fromAddress=account.address,
         )
 
         if kwargs.get("routingStrategy"):
@@ -318,15 +316,14 @@ class EnsoWalletApprove(EnsoBaseTool):
         url = f"{base_url}/api/v1/wallet/approve"
         context: SkillContext = self.context_from_config(config)
         api_token = self.get_api_token(context)
-        chain_provider = self.get_chain_provider(context)
-        wallet = await self.get_wallet(context)
+        account = await self.get_account(context)
 
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
-        from_address = wallet.addresses[0].address_id
+        from_address = account.address
 
         params = EnsoWalletApproveInput(
             tokenAddress=tokenAddress,
@@ -352,20 +349,27 @@ class EnsoWalletApprove(EnsoBaseTool):
                 content = EnsoWalletApproveOutput(**json_dict)
                 artifact = EnsoWalletApproveArtifact(**json_dict)
 
-                rpc_url = chain_provider.get_chain_config_by_id(chainId).rpc_url
-                contract = EvmContractWrapper(rpc_url, ABI_ERC20, artifact.tx)
-
-                fn, fn_args = contract.fn_and_args
-                fn_args["value"] = str(fn_args["value"])
-
-                invocation = wallet.invoke_contract(
-                    contract_address=contract.dst_addr,
-                    method=fn.fn_name,
-                    abi=ABI_ERC20,
-                    args=fn_args,
-                ).wait()
-
-                artifact.txHash = invocation.transaction.transaction_hash
+                # Use the wallet provider to send the transaction
+                wallet_provider = await self.get_wallet_provider(context)
+
+                # Extract transaction data from the Enso API response
+                tx_data = json_dict.get("tx", {})
+                if tx_data:
+                    # Send the transaction using the wallet provider
+                    tx_hash = wallet_provider.send_transaction(
+                        {
+                            "to": tx_data.get("to"),
+                            "data": tx_data.get("data", "0x"),
+                            "value": tx_data.get("value", 0),
+                        }
+                    )
+
+                    # Wait for transaction confirmation
+                    wallet_provider.wait_for_transaction_receipt(tx_hash)
+                    artifact.txHash = tx_hash
+                else:
+                    # For now, return without executing the transaction if no tx data
+                    artifact.txHash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 
                 # Return the parsed response
                 return (content, artifact)

intentkit-0.6.0.dev6/clients/cdp.py

@@ -1,53 +0,0 @@
-from typing import Dict, Optional
-
-from cdp import Wallet
-from coinbase_agentkit import (
-    CdpWalletProvider,
-    CdpWalletProviderConfig,
-)
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.models.agent import Agent
-from intentkit.models.agent_data import AgentData
-
-_clients: Dict[str, "CdpClient"] = {}
-
-
-class CdpClient:
-    def __init__(self, agent_id: str, skill_store: SkillStoreABC) -> None:
-        self._agent_id = agent_id
-        self._skill_store = skill_store
-        self._wallet_provider: Optional[CdpWalletProvider] = None
-        self._wallet_provider_config: Optional[CdpWalletProviderConfig] = None
-
-    async def get_wallet_provider(self) -> CdpWalletProvider:
-        if self._wallet_provider:
-            return self._wallet_provider
-        agent: Agent = await self._skill_store.get_agent_config(self._agent_id)
-        agent_data: AgentData = await self._skill_store.get_agent_data(self._agent_id)
-        network_id = agent.network_id or agent.cdp_network_id
-        self._wallet_provider_config = CdpWalletProviderConfig(
-            api_key_name=self._skill_store.get_system_config("cdp_api_key_name"),
-            api_key_private_key=self._skill_store.get_system_config(
-                "cdp_api_key_private_key"
-            ),
-            network_id=network_id,
-            wallet_data=agent_data.cdp_wallet_data,
-        )
-        self._wallet_provider = CdpWalletProvider(self._wallet_provider_config)
-        return self._wallet_provider
-
-    async def get_wallet(self) -> Wallet:
-        wallet_provider = await self.get_wallet_provider()
-        return wallet_provider._wallet
-
-    async def get_provider_config(self) -> CdpWalletProviderConfig:
-        if not self._wallet_provider_config:
-            await self.get_wallet_provider()
-        return self._wallet_provider_config
-
-
-async def get_cdp_client(agent_id: str, skill_store: SkillStoreABC) -> "CdpClient":
-    if agent_id not in _clients:
-        _clients[agent_id] = CdpClient(agent_id, skill_store)
-    return _clients[agent_id]