intentkit 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

{skills → intentkit/skills}/base.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from typing import Any, Callable, Dict, Literal, NotRequired, Optional, TypedDict, Union
 
@@ -30,10 +31,33 @@ class SkillConfig(TypedDict):
 
 
 class SkillContext(BaseModel):
-    agent: Agent
-    config: Dict[str, Any]
-    user_id: Optional[str]
+    skill_category: str
+    agent_id: str
+    user_id: Optional[str] = None
+    chat_id: Optional[str] = None
+    app_id: Optional[str] = None
     entrypoint: Literal["web", "twitter", "telegram", "trigger", "api"]
+    is_private: bool
+    payer: Optional[str] = None
+    _agent: Optional[Agent] = None
+
+    @property
+    def agent(self) -> Agent:
+        if self._agent is None:
+            self._agent = asyncio.run(Agent.get(self.agent_id))
+        return self._agent
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        agent = self.agent
+        config = None
+        if agent.skills:
+            config = agent.skills.get(self.skill_category)
+        if not config:
+            raise ValueError(
+                f"Skill {self.skill_category} not found in agent {self.agent_id}"
+            )
+        return config
 
 
 class IntentKitSkill(BaseTool):
@@ -156,19 +180,15 @@ class IntentKitSkill(BaseTool):
     def context_from_config(self, runner_config: RunnableConfig) -> SkillContext:
         if "configurable" not in runner_config:
             raise ValueError("configurable not in runner_config")
-        if "agent" not in runner_config["configurable"]:
-            raise ValueError("agent not in runner_config['configurable']")
-        agent: Agent = runner_config["configurable"].get("agent")
-        config = None
-        if agent.skills:
-            config = agent.skills.get(self.category)
-        if not config:
-            config = getattr(agent, self.category + "_config", {})
-        if not config:
-            config = {}
+        configurable = runner_config["configurable"]
+        if not configurable:
+            raise ValueError("configurable in runnable config is empty")
         return SkillContext(
-            agent=agent,
-            config=config,
-            user_id=runner_config["configurable"].get("user_id"),
-            entrypoint=runner_config["configurable"].get("entrypoint"),
+            skill_category=self.category,
+            agent_id=configurable.get("agent_id"),
+            user_id=configurable.get("user_id"),
+            app_id=configurable.get("app_id"),
+            chat_id=configurable.get("chat_id"),
+            entrypoint=configurable.get("entrypoint"),
+            is_private=configurable.get("is_private"),
         )

{skills → intentkit/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,
@@ -26,9 +25,6 @@ from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.cdp.base import CDPBaseTool
 from intentkit.skills.cdp.get_balance import GetBalance
 
-# Cache skills at the system level, because they are stateless
-_cache: dict[str, CDPBaseTool] = {}
-
 
 class SkillStates(TypedDict):
     get_balance: SkillState
@@ -37,10 +33,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 +89,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 +113,9 @@ async def get_skills(
     tools = []
     for skill in available_skills:
         if skill == "get_balance":
+            # Get the account object for the custom GetBalance skill
             tools.append(
                 GetBalance(
-                    wallet=cdp_wallet_provider._wallet,
                     agent_id=agent_id,
                     skill_store=store,
                 )

intentkit/skills/cdp/get_balance.py

@@ -0,0 +1,133 @@
+from typing import Optional, 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: Optional[str] = Field(
+        default=None,
+        description="The asset ID to get the balance for (e.g., 'eth', 'usdc', or a valid contract address). If not provided, returns all token balances.",
+    )
+
+
+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
+
+    name: str = "cdp_get_balance"
+    description: str = (
+        "This tool will get the balance of all the addresses in the wallet. If asset_id is provided, it returns the balance for that specific asset. "
+        "If no asset_id is provided, it returns all token balances. "
+        "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: Optional[str] = None) -> str:
+        """Async implementation of the tool to get balance.
+
+        Args:
+            asset_id (Optional[str]): The asset ID to get the balance for. If None, returns all token balances.
+
+        Returns:
+            str: A message containing the balance information or error message.
+        """
+        try:
+            # Get network information from CDP client
+            cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
+            provider = await cdp_client.get_wallet_provider()
+            account: EvmServerAccount = provider._account
+            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",
+                "ethereum-mainnet": "ethereum",
+            }
+            api_network = network_mapping.get(network_id, network_id)
+
+            # If no asset_id provided, return all token balances
+            if asset_id is None:
+                try:
+                    # Get native ETH balance
+                    balance_wei = provider.get_balance()
+                    balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
+
+                    # Get all token balances
+                    token_balances = await account.list_token_balances(api_network)
+
+                    result = [f"ETH balance: {balance_eth} ETH"]
+
+                    for balance in token_balances.balances:
+                        result.append(
+                            f"{balance.token.symbol} balance: {balance.amount.decimals} {balance.token.name}"
+                        )
+
+                    return f"All balances for account {account.address}:\n" + "\n".join(
+                        result
+                    )
+
+                except Exception as e:
+                    return f"Error getting all balances: {e!s}"
+
+            # For native ETH balance, use the account's balance directly
+            if asset_id.lower() == "eth":
+                try:
+                    # Get native balance using Web3
+                    balance_wei = provider.get_balance()
+                    balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
+                    return (
+                        f"ETH balance for account {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 account.list_token_balances(api_network)
+
+                # Find the balance for the specific asset
+                target_balance = None
+                for balance in token_balances.balances:
+                    if balance.token.symbol.lower() == asset_id.lower():
+                        target_balance = balance
+                        break
+
+                if target_balance:
+                    return f"Balance for {asset_id} in account {account.address}: {target_balance.amount.decimals} {target_balance.token.name}"
+                else:
+                    return f"No balance found for asset {asset_id} in account {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: Optional[str] = None) -> 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"
+        )

{skills → intentkit/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",

{skills → intentkit/skills}/cryptocompare/fetch_news.py

@@ -57,7 +57,7 @@ class CryptoCompareFetchNews(CryptoCompareBaseTool):
             context = self.context_from_config(config)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent.id, max_requests=5, interval=60)
+            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
 
             # Get API key from context
             api_key = context.config.get("api_key")
@@ -93,4 +93,4 @@ class CryptoCompareFetchNews(CryptoCompareBaseTool):
 
         except Exception as e:
             logger.error("Error fetching news: %s", str(e))
-            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

{skills → intentkit/skills}/cryptocompare/fetch_price.py

@@ -67,7 +67,7 @@ class CryptoCompareFetchPrice(CryptoCompareBaseTool):
             context = self.context_from_config(config)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent.id, max_requests=10, interval=60)
+            await self.check_rate_limit(context.agent_id, max_requests=10, interval=60)
 
             # Get API key from context
             api_key = context.config.get("api_key")
@@ -96,4 +96,4 @@ class CryptoCompareFetchPrice(CryptoCompareBaseTool):
 
         except Exception as e:
             logger.error("Error fetching price: %s", str(e))
-            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

{skills → intentkit/skills}/cryptocompare/fetch_top_exchanges.py

@@ -73,7 +73,7 @@ class CryptoCompareFetchTopExchanges(CryptoCompareBaseTool):
             context = self.context_from_config(config)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent.id, max_requests=5, interval=60)
+            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
 
             # Get API key from context
             api_key = context.config.get("api_key")
@@ -110,4 +110,4 @@ class CryptoCompareFetchTopExchanges(CryptoCompareBaseTool):
 
         except Exception as e:
             logger.error("Error fetching top exchanges: %s", str(e))
-            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

{skills → intentkit/skills}/cryptocompare/fetch_top_market_cap.py

@@ -66,7 +66,7 @@ class CryptoCompareFetchTopMarketCap(CryptoCompareBaseTool):
             context = self.context_from_config(config)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent.id, max_requests=5, interval=60)
+            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
 
             # Get API key from context
             api_key = context.config.get("api_key")
@@ -106,4 +106,4 @@ class CryptoCompareFetchTopMarketCap(CryptoCompareBaseTool):
 
         except Exception as e:
             logger.error("Error fetching top market cap: %s", str(e))
-            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

{skills → intentkit/skills}/cryptocompare/fetch_top_volume.py

@@ -65,7 +65,7 @@ class CryptoCompareFetchTopVolume(CryptoCompareBaseTool):
             context = self.context_from_config(config)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent.id, max_requests=5, interval=60)
+            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
 
             # Get API key from context
             api_key = context.config.get("api_key")
@@ -105,4 +105,4 @@ class CryptoCompareFetchTopVolume(CryptoCompareBaseTool):
 
         except Exception as e:
             logger.error("Error fetching top volume: %s", str(e))
-            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

{skills → intentkit/skills}/cryptocompare/fetch_trading_signals.py

@@ -68,7 +68,7 @@ class CryptoCompareFetchTradingSignals(CryptoCompareBaseTool):
             context = self.context_from_config(config)
 
             # Check rate limit
-            await self.check_rate_limit(context.agent.id, max_requests=5, interval=60)
+            await self.check_rate_limit(context.agent_id, max_requests=5, interval=60)
 
             # Get API key from context
             api_key = context.config.get("api_key")
@@ -104,4 +104,4 @@ class CryptoCompareFetchTradingSignals(CryptoCompareBaseTool):
 
         except Exception as e:
             logger.error("Error fetching trading signals: %s", str(e))
-            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e
+            raise type(e)(f"[agent:{context.agent_id}]: {e}") from e

{skills → intentkit/skills}/defillama/base.py

@@ -52,7 +52,7 @@ class DefiLlamaBaseTool(IntentKitSkill):
             Rate limit status and error message if limited
         """
         rate_limit = await self.skill_store.get_agent_skill_data(
-            context.agent.id, self.name, "rate_limit"
+            context.agent_id, self.name, "rate_limit"
         )
         current_time = datetime.now(tz=timezone.utc)
 
@@ -67,7 +67,7 @@ class DefiLlamaBaseTool(IntentKitSkill):
 
             rate_limit["count"] += 1
             await self.skill_store.save_agent_skill_data(
-                context.agent.id, self.name, "rate_limit", rate_limit
+                context.agent_id, self.name, "rate_limit", rate_limit
             )
             return False, None
 
@@ -76,7 +76,7 @@ class DefiLlamaBaseTool(IntentKitSkill):
             "reset_time": (current_time + timedelta(minutes=interval)).isoformat(),
         }
         await self.skill_store.save_agent_skill_data(
-            context.agent.id, self.name, "rate_limit", new_rate_limit
+            context.agent_id, self.name, "rate_limit", new_rate_limit
         )
         return False, None
 

{skills → intentkit/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]:
-        client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
-        return await client.get_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_provider()
 
     def get_chain_provider(self, context: SkillContext) -> Optional[ChainProvider]:
         return self.skill_store.get_system_config("chain_provider")

{skills → intentkit/skills}/enso/networks.py

@@ -86,7 +86,7 @@ class EnsoGetNetworks(EnsoBaseTool):
                     )
 
                 await self.skill_store.save_agent_skill_data(
-                    context.agent.id,
+                    context.agent_id,
                     "enso_get_networks",
                     "networks",
                     networks_memory,

{skills → intentkit/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
 
@@ -186,10 +184,9 @@ class EnsoRouteShortcut(EnsoBaseTool):
         """
 
         context: SkillContext = self.context_from_config(config)
-        agent_id = context.agent.id
+        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
 

{skills → intentkit/skills}/enso/tokens.py

@@ -158,7 +158,7 @@ class EnsoGetTokens(EnsoBaseTool):
         url = f"{base_url}/api/v1/tokens"
 
         context: SkillContext = self.context_from_config(config)
-        agent_id = context.agent.id
+        agent_id = context.agent_id
         api_token = self.get_api_token(context)
         main_tokens = self.get_main_tokens(context)
         headers = {