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

intentkit/skills/elfa/utils.py

@@ -1,9 +1,9 @@
 """Utility functions for Elfa skills."""
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
 from .base import base_url
@@ -14,13 +14,13 @@ class ElfaResponse(BaseModel):
 
     success: bool
     data: Any = None
-    metadata: Optional[Dict[str, Any]] = None
+    metadata: dict[str, Any] | None = None
 
 
 async def make_elfa_request(
     endpoint: str,
     api_key: str,
-    params: Optional[Dict[str, Any]] = None,
+    params: dict[str, Any] | None = None,
     timeout: int = 30,
 ) -> ElfaResponse:
     """
@@ -82,32 +82,32 @@ async def make_elfa_request(
 class RepostBreakdown(BaseModel):
     """Repost breakdown data."""
 
-    smart: Optional[int] = None
-    ct: Optional[int] = None
+    smart: int | None = None
+    ct: int | None = None
 
 
 class Account(BaseModel):
     """Account information."""
 
-    username: Optional[str] = None
-    isVerified: Optional[bool] = None
+    username: str | None = None
+    isVerified: bool | None = None
 
 
 class MentionData(BaseModel):
     """Base mention data structure used across multiple endpoints."""
 
-    tweetId: Optional[str] = Field(None, description="Tweet ID")
-    link: Optional[str] = Field(None, description="Link to the tweet")
-    likeCount: Optional[int] = Field(None, description="Number of likes")
-    repostCount: Optional[int] = Field(None, description="Number of reposts")
-    viewCount: Optional[int] = Field(None, description="Number of views")
-    quoteCount: Optional[int] = Field(None, description="Number of quotes")
-    replyCount: Optional[int] = Field(None, description="Number of replies")
-    bookmarkCount: Optional[int] = Field(None, description="Number of bookmarks")
-    mentionedAt: Optional[str] = Field(None, description="When mentioned")
-    type: Optional[str] = Field(None, description="Post type")
-    account: Optional[Account] = Field(None, description="Account information")
-    repostBreakdown: Optional[RepostBreakdown] = Field(
+    tweetId: str | None = Field(None, description="Tweet ID")
+    link: str | None = Field(None, description="Link to the tweet")
+    likeCount: int | None = Field(None, description="Number of likes")
+    repostCount: int | None = Field(None, description="Number of reposts")
+    viewCount: int | None = Field(None, description="Number of views")
+    quoteCount: int | None = Field(None, description="Number of quotes")
+    replyCount: int | None = Field(None, description="Number of replies")
+    bookmarkCount: int | None = Field(None, description="Number of bookmarks")
+    mentionedAt: str | None = Field(None, description="When mentioned")
+    type: str | None = Field(None, description="Post type")
+    account: Account | None = Field(None, description="Account information")
+    repostBreakdown: RepostBreakdown | None = Field(
         None, description="Repost breakdown"
     )
 
@@ -115,15 +115,13 @@ class MentionData(BaseModel):
 class SmartStatsData(BaseModel):
     """Smart stats data structure."""
 
-    smartFollowingCount: Optional[int] = Field(
-        None, description="Smart following count"
-    )
-    averageEngagement: Optional[float] = Field(None, description="Average engagement")
-    averageReach: Optional[float] = Field(None, description="Average reach")
-    smartFollowerCount: Optional[int] = Field(None, description="Smart follower count")
-    followerCount: Optional[int] = Field(None, description="Total follower count")
+    smartFollowingCount: int | None = Field(None, description="Smart following count")
+    averageEngagement: float | None = Field(None, description="Average engagement")
+    averageReach: float | None = Field(None, description="Average reach")
+    smartFollowerCount: int | None = Field(None, description="Smart follower count")
+    followerCount: int | None = Field(None, description="Total follower count")
 
 
-def clean_params(params: Dict[str, Any]) -> Dict[str, Any]:
+def clean_params(params: dict[str, Any]) -> dict[str, Any]:
     """Remove None values from parameters dict."""
     return {k: v for k, v in params.items() if v is not None}

intentkit/skills/enso/__init__.py

@@ -1,9 +1,8 @@
 """Enso skills."""
 
 import logging
-from typing import List, NotRequired, TypedDict
+from typing import NotRequired, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.enso.base import EnsoBaseTool
 from intentkit.skills.enso.best_yield import EnsoGetBestYield
@@ -36,13 +35,12 @@ class Config(SkillConfig):
 
     states: SkillStates
     api_token: NotRequired[str]
-    main_tokens: List[str]
+    main_tokens: NotRequired[list[str]]
 
 
 async def get_skills(
     config: Config,
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[EnsoBaseTool]:
     """Get all Enso skills."""
@@ -58,7 +56,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_enso_skill(name, store)
+        skill = get_enso_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -66,49 +64,31 @@ async def get_skills(
 
 def get_enso_skill(
     name: str,
-    skill_store: SkillStoreABC,
 ) -> EnsoBaseTool:
     """Get an Enso skill by name.
 
     Args:
         name: The name of the skill to get
-        skill_store: The skill store for persisting data
 
     Returns:
         The requested Enso skill
     """
     if name == "get_networks":
-        return EnsoGetNetworks(
-            skill_store=skill_store,
-        )
+        return EnsoGetNetworks()
     if name == "get_tokens":
-        return EnsoGetTokens(
-            skill_store=skill_store,
-        )
+        return EnsoGetTokens()
     if name == "get_prices":
-        return EnsoGetPrices(
-            skill_store=skill_store,
-        )
+        return EnsoGetPrices()
     if name == "get_wallet_approvals":
-        return EnsoGetWalletApprovals(
-            skill_store=skill_store,
-        )
+        return EnsoGetWalletApprovals()
     if name == "get_wallet_balances":
-        return EnsoGetWalletBalances(
-            skill_store=skill_store,
-        )
+        return EnsoGetWalletBalances()
     if name == "wallet_approve":
-        return EnsoWalletApprove(
-            skill_store=skill_store,
-        )
+        return EnsoWalletApprove()
     if name == "route_shortcut":
-        return EnsoRouteShortcut(
-            skill_store=skill_store,
-        )
+        return EnsoRouteShortcut()
     if name == "get_best_yield":
-        return EnsoGetBestYield(
-            skill_store=skill_store,
-        )
+        return EnsoGetBestYield()
     else:
         logger.warning(f"Unknown Enso skill: {name}")
         return None

intentkit/skills/enso/base.py

@@ -1,18 +1,20 @@
-from typing import Optional, Type
+from decimal import Decimal
 
-from cdp import EvmServerAccount
-from coinbase_agentkit import CdpEvmServerWalletProvider
-from langchain.tools.base import ToolException
+from coinbase_agentkit import CdpEvmWalletProvider
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.abstracts.graph import AgentContext
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.clients import CdpClient, get_cdp_client
+from intentkit.clients import get_wallet_provider as get_agent_wallet_provider
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
-from intentkit.utils.chain import ChainProvider, NetworkId
+from intentkit.utils.chain import (
+    ChainProvider,
+    network_to_id,
+    resolve_quicknode_network,
+)
 
 base_url = "https://api.enso.finance"
-default_chain_id = int(NetworkId.BaseMainnet)
 
 
 class EnsoBaseTool(IntentKitSkill):
@@ -20,39 +22,25 @@ class EnsoBaseTool(IntentKitSkill):
 
     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]
 
-    async def get_account(self, context: AgentContext) -> 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: AgentContext
-    ) -> Optional[CdpEvmServerWalletProvider]:
+    async def get_wallet_provider(self, context: AgentContext) -> CdpEvmWalletProvider:
         """Get the wallet provider from the CDP client.
 
         Args:
             context: The skill context containing agent information.
 
         Returns:
-            Optional[CdpEvmServerWalletProvider]: The wallet provider if available.
+            CdpEvmWalletProvider | None: The wallet provider if available.
         """
-        client: CdpClient = await get_cdp_client(context.agent.id, self.skill_store)
-        return await client.get_wallet_provider()
+        return await get_agent_wallet_provider(context.agent)
 
-    def get_chain_provider(self, context: AgentContext) -> Optional[ChainProvider]:
-        return self.skill_store.get_system_config("chain_provider")
+    async def get_wallet_address(self, context: AgentContext) -> str:
+        provider: CdpEvmWalletProvider = await self.get_wallet_provider(context)
+        return provider.get_address()
+
+    def get_chain_provider(self, context: AgentContext) -> ChainProvider | None:
+        return config.chain_provider
 
     def get_main_tokens(self, context: AgentContext) -> list[str]:
         skill_config = context.agent.skill_config(self.category)
@@ -60,12 +48,11 @@ class EnsoBaseTool(IntentKitSkill):
             return skill_config["main_tokens"]
         return []
 
-    def get_api_key(self) -> str:
-        context = self.get_context()
+    def get_api_token(self, context: AgentContext) -> str:
         skill_config = context.agent.skill_config(self.category)
         api_key_provider = skill_config.get("api_key_provider")
         if api_key_provider == "platform":
-            return self.skill_store.get_system_config("enso_api_token")
+            return config.enso_api_token
         # for backward compatibility, may only have api_token in skill_config
         elif skill_config.get("api_token"):
             return skill_config.get("api_token")
@@ -74,6 +61,38 @@ class EnsoBaseTool(IntentKitSkill):
                 f"Invalid API key provider: {api_key_provider}, or no api_token in config"
             )
 
+    def resolve_chain_id(
+        self, context: AgentContext, chain_id: int | None = None
+    ) -> int:
+        if chain_id:
+            return chain_id
+
+        agent = context.agent
+        try:
+            network = resolve_quicknode_network(agent.network_id)
+        except ValueError as exc:  # pragma: no cover - defensive
+            raise ToolException(
+                f"Unsupported network configured for agent: {agent.network_id}"
+            ) from exc
+
+        network_id = network_to_id.get(network)
+        if network_id is None:
+            raise ToolException(
+                f"Unable to determine chain id for network: {agent.network_id}"
+            )
+        return int(network_id)
+
     @property
     def category(self) -> str:
         return "enso"
+
+
+def format_amount_with_decimals(amount: object, decimals: int | None) -> str | None:
+    if amount is None or decimals is None:
+        return None
+
+    try:
+        value = Decimal(str(amount)) / (Decimal(10) ** decimals)
+        return format(value, "f")
+    except Exception:  # pragma: no cover - defensive
+        return None

intentkit/skills/enso/best_yield.py

@@ -1,17 +1,8 @@
-from typing import List, Optional, Type
-
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.skills.enso.base import (
-    EnsoBaseTool,
-    base_url,
-)
-from intentkit.utils.chain import NetworkId
-
-# Chain ID for Base Mainnet
-BASE_CHAIN_ID = int(NetworkId.BaseMainnet)
+from intentkit.skills.enso.base import EnsoBaseTool, base_url
 
 
 class EnsoGetBestYieldInput(BaseModel):
@@ -21,9 +12,9 @@ class EnsoGetBestYieldInput(BaseModel):
         "USDC",
         description="Symbol of the token to find the best yield for (e.g., 'USDC', 'ETH', 'USDT')",
     )
-    chain_id: int = Field(
-        BASE_CHAIN_ID,
-        description="The blockchain chain ID. Default is Base Mainnet (8453)",
+    chain_id: int | None = Field(
+        None,
+        description="The blockchain chain ID. Defaults to the agent's configured network.",
     )
     top_n: int = Field(
         5,
@@ -47,8 +38,8 @@ class YieldOption(BaseModel):
         None, description="Primary contract address for interacting with the protocol"
     )
     apy: float = Field(None, description="Annual Percentage Yield")
-    tvl: Optional[float] = Field(None, description="Total Value Locked in the protocol")
-    underlying_tokens: List[str] = Field(
+    tvl: float | None = Field(None, description="Total Value Locked in the protocol")
+    underlying_tokens: list[str] = Field(
         [], description="List of underlying token symbols"
     )
 
@@ -56,7 +47,7 @@ class YieldOption(BaseModel):
 class EnsoGetBestYieldOutput(BaseModel):
     """Output containing the best yield options."""
 
-    best_options: List[YieldOption] = Field(
+    best_options: list[YieldOption] = Field(
         [], description="List of best yield options sorted by APY (descending)"
     )
     token_symbol: str = Field(None, description="Symbol of the token searched for")
@@ -75,12 +66,12 @@ class EnsoGetBestYield(EnsoBaseTool):
         "Find the best yield options for a specific token (default: USDC) across all protocols "
         "on a blockchain network (default: Base). Results are sorted by APY in descending order."
     )
-    args_schema: Type[BaseModel] = EnsoGetBestYieldInput
+    args_schema: type[BaseModel] = EnsoGetBestYieldInput
 
     async def _arun(
         self,
         token_symbol: str = "USDC",
-        chain_id: int = BASE_CHAIN_ID,
+        chain_id: int | None = None,
         top_n: int = 5,
         **kwargs,
     ) -> EnsoGetBestYieldOutput:
@@ -89,7 +80,7 @@ class EnsoGetBestYield(EnsoBaseTool):
 
         Args:
             token_symbol (str): Symbol of the token to find the best yield for (default: USDC)
-            chain_id (int): The chain id of the network (default: Base Mainnet)
+            chain_id (int | None): The chain id of the network. Defaults to the agent's configured network.
             top_n (int): Number of top yield options to return
 
         Returns:
@@ -99,16 +90,17 @@ class EnsoGetBestYield(EnsoBaseTool):
             ToolException: If there's an error accessing the Enso API.
         """
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chain_id)
         api_token = self.get_api_token(context)
 
         if not api_token:
             raise ToolException("No API token found for Enso Finance")
 
         # Get the chain name for the given chain ID
-        chain_name = await self._get_chain_name(api_token, chain_id)
+        chain_name = await self._get_chain_name(api_token, resolved_chain_id)
 
         # Get all protocols on the specified chain
-        protocols = await self._get_protocols(api_token, chain_id)
+        protocols = await self._get_protocols(api_token, resolved_chain_id)
 
         # Collect all yield options from all protocols
         all_yield_options = []
@@ -119,7 +111,7 @@ class EnsoGetBestYield(EnsoBaseTool):
 
             # Get yield-bearing tokens for this protocol
             tokens = await self._get_protocol_tokens(
-                api_token, chain_id, protocol_slug, token_symbol
+                api_token, resolved_chain_id, protocol_slug, token_symbol
             )
 
             # Process tokens to extract yield options
@@ -170,7 +162,7 @@ class EnsoGetBestYield(EnsoBaseTool):
         return EnsoGetBestYieldOutput(
             best_options=top_options,
             token_symbol=token_symbol,
-            chain_id=chain_id,
+            chain_id=resolved_chain_id,
             chain_name=chain_name,
         )
 

intentkit/skills/enso/networks.py

@@ -1,14 +1,11 @@
 import logging
-from typing import Type
 
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
 from .base import EnsoBaseTool, base_url
 
-logger = logging.getLogger(__name__)
-
 
 class EnsoGetNetworksInput(BaseModel):
     """
@@ -38,6 +35,9 @@ class EnsoGetNetworksOutput(BaseModel):
     )
 
 
+logger = logging.getLogger(__name__)
+
+
 class EnsoGetNetworks(EnsoBaseTool):
     """
     Tool for retrieving networks and their corresponding chainId, the output should be kept.
@@ -45,7 +45,7 @@ class EnsoGetNetworks(EnsoBaseTool):
 
     name: str = "enso_get_networks"
     description: str = "Retrieve networks supported by the Enso API"
-    args_schema: Type[BaseModel] = EnsoGetNetworksInput
+    args_schema: type[BaseModel] = EnsoGetNetworksInput
 
     async def _arun(self, **kwargs) -> EnsoGetNetworksOutput:
         """
@@ -82,12 +82,7 @@ class EnsoGetNetworks(EnsoBaseTool):
                         exclude_none=True
                     )
 
-                await self.skill_store.save_agent_skill_data(
-                    context.agent_id,
-                    "enso_get_networks",
-                    "networks",
-                    networks_memory,
-                )
+                await self.save_agent_skill_data("networks", networks_memory)
 
                 return EnsoGetNetworksOutput(res=networks)
             except httpx.RequestError as req_err:

intentkit/skills/enso/prices.py

@@ -1,16 +1,12 @@
-from typing import Type
-
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from .base import EnsoBaseTool, base_url, default_chain_id
+from .base import EnsoBaseTool, base_url
 
 
 class EnsoGetPricesInput(BaseModel):
-    chainId: int = Field(
-        default_chain_id, description="Blockchain chain ID of the token"
-    )
+    chainId: int | None = Field(None, description="Blockchain chain ID of the token")
     address: str = Field(
         "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
         description="Contract address of the token",
@@ -38,27 +34,26 @@ class EnsoGetPrices(EnsoBaseTool):
 
     name: str = "enso_get_prices"
     description: str = "Retrieve the price of a token by chain ID and contract address"
-    args_schema: Type[BaseModel] = EnsoGetPricesInput
+    args_schema: type[BaseModel] = EnsoGetPricesInput
 
     async def _arun(
         self,
         address: str,
-        chainId: int = default_chain_id,
+        chainId: int | None = None,
         **kwargs,
     ) -> EnsoGetPricesOutput:
         """
         Asynchronous function to request the token price from the API.
 
         Args:
-            chainId (int): The blockchain's chain ID.
+            chainId (int | None): The blockchain's chain ID. Defaults to the agent's configured network.
             address (str): Contract address of the token.
 
         Returns:
             EnsoGetPricesOutput: Token price response or error message.
         """
-        url = f"{base_url}/api/v1/prices/{str(chainId)}/{address}"
-
         context = self.get_context()
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
 
         headers = {
@@ -68,7 +63,10 @@ class EnsoGetPrices(EnsoBaseTool):
 
         async with httpx.AsyncClient() as client:
             try:
-                response = await client.get(url, headers=headers)
+                response = await client.get(
+                    f"{base_url}/api/v1/prices/{str(resolved_chain_id)}/{address}",
+                    headers=headers,
+                )
                 response.raise_for_status()
                 json_dict = response.json()