intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/skills/portfolio/base.py

@@ -3,12 +3,13 @@
 import asyncio
 import logging
 from abc import ABC
-from typing import Any, Dict, Type
+from typing import Any
 
 import aiohttp
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
 from intentkit.skills.portfolio.constants import MORALIS_API_BASE_URL
 
@@ -20,23 +21,26 @@ class PortfolioBaseTool(IntentKitSkill, ABC):
 
     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]
 
     def get_api_key(self) -> str:
         context = self.get_context()
         skill_config = context.agent.skill_config(self.category)
         if skill_config.get("api_key_provider") == "agent_owner":
-            return skill_config.get("api_key")
-        return self.skill_store.get_system_config("moralis_api_key")
+            api_key = skill_config.get("api_key")
+        else:
+            api_key = config.moralis_api_key
+
+        if not api_key:
+            raise ToolException("Moralis API key is not configured.")
+
+        return api_key
 
     @property
     def category(self) -> str:
         return "portfolio"
 
-    def _prepare_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _prepare_params(self, params: dict[str, Any]) -> dict[str, Any]:
         """Convert boolean values to lowercase strings for API compatibility.
 
         Args:
@@ -61,9 +65,9 @@ class PortfolioBaseTool(IntentKitSkill, ABC):
         method: str,
         endpoint: str,
         api_key: str,
-        params: Dict[str, Any] = None,
-        data: Dict[str, Any] = None,
-    ) -> Dict[str, Any]:
+        params: dict[str, Any] = None,
+        data: dict[str, Any] = None,
+    ) -> dict[str, Any]:
         """Make a request to the Moralis API.
 
         Args:
@@ -95,13 +99,23 @@ class PortfolioBaseTool(IntentKitSkill, ABC):
             ) as response:
                 if response.status >= 400:
                     error_text = await response.text()
-                    logger.error(f"portfolio/base.py: API error: {error_text}")
-                    return {
-                        "error": f"API error: {response.status}",
-                        "details": error_text,
-                    }
-
-                return await response.json()
+                    logger.error(
+                        "portfolio/base.py: API error %s for %s", response.status, url
+                    )
+                    raise ToolException(
+                        f"Moralis API error: {response.status} - {error_text}"
+                    )
+
+                try:
+                    return await response.json()
+                except aiohttp.ContentTypeError as exc:
+                    await response.text()
+                    logger.error(
+                        "portfolio/base.py: Failed to decode JSON response from %s", url
+                    )
+                    raise ToolException(
+                        "Moralis API returned invalid JSON payload."
+                    ) from exc
 
     def _run(self, *args: Any, **kwargs: Any) -> Any:
         """Execute the tool synchronously by running the async version in a loop."""

intentkit/skills/portfolio/schema.json

@@ -5,18 +5,16 @@
   "description": "Access blockchain wallet data and analytics through Moralis APIs for portfolio tracking, token balances, and investment performance",
   "x-icon": "https://ai.service.crestal.dev/skills/portfolio/moralis.png",
   "x-tags": [
-    "Blockchain",
-    "Web3",
+    "Analytics",
     "Crypto",
-    "Portfolio",
-    "Wallet"
+    "DeFi"
   ],
   "properties": {
     "enabled": {
       "type": "boolean",
       "title": "Enabled",
       "description": "Whether this skill is enabled",
-      "default": true
+      "default": false
     },
     "states": {
       "type": "object",

intentkit/skills/portfolio/token_balances.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -20,39 +20,39 @@ class TokenBalancesInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    to_block: Optional[int] = Field(
+    to_block: int | None = Field(
         description="The block number up to which the balances will be checked.",
         default=None,
     )
-    token_addresses: Optional[List[str]] = Field(
+    token_addresses: list[str] | None = Field(
         description="The specific token addresses to get balances for.",
         default=None,
     )
-    exclude_spam: Optional[bool] = Field(
+    exclude_spam: bool | None = Field(
         description="Exclude spam tokens from the result.",
         default=True,
     )
-    exclude_unverified_contracts: Optional[bool] = Field(
+    exclude_unverified_contracts: bool | None = Field(
         description="Exclude unverified contracts from the result.",
         default=True,
     )
-    cursor: Optional[str] = Field(
+    cursor: str | None = Field(
         description="The cursor for pagination.",
         default=None,
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The number of results per page.",
         default=DEFAULT_LIMIT,
     )
-    exclude_native: Optional[bool] = Field(
+    exclude_native: bool | None = Field(
         description="Exclude native balance from the result.",
         default=None,
     )
-    max_token_inactivity: Optional[int] = Field(
+    max_token_inactivity: int | None = Field(
         description="Exclude tokens inactive for more than the given amount of days.",
         default=None,
     )
-    min_pair_side_liquidity_usd: Optional[float] = Field(
+    min_pair_side_liquidity_usd: float | None = Field(
         description="Exclude tokens with liquidity less than the specified amount in USD.",
         default=None,
     )
@@ -70,23 +70,23 @@ class TokenBalances(PortfolioBaseTool):
         "Get token balances for a specific wallet address and their token prices in USD. "
         "Includes options to exclude spam and unverified contracts."
     )
-    args_schema: Type[BaseModel] = TokenBalancesInput
+    args_schema: type[BaseModel] = TokenBalancesInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        to_block: Optional[int] = None,
-        token_addresses: Optional[List[str]] = None,
-        exclude_spam: Optional[bool] = True,
-        exclude_unverified_contracts: Optional[bool] = True,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = DEFAULT_LIMIT,
-        exclude_native: Optional[bool] = None,
-        max_token_inactivity: Optional[int] = None,
-        min_pair_side_liquidity_usd: Optional[float] = None,
+        to_block: int | None = None,
+        token_addresses: list[str] | None = None,
+        exclude_spam: bool | None = True,
+        exclude_unverified_contracts: bool | None = True,
+        cursor: str | None = None,
+        limit: int | None = DEFAULT_LIMIT,
+        exclude_native: bool | None = None,
+        max_token_inactivity: int | None = None,
+        min_pair_side_liquidity_usd: float | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch token balances from Moralis.
 
         Args:

intentkit/skills/portfolio/wallet_approvals.py

@@ -1,6 +1,7 @@
 import logging
-from typing import Any, Dict, Optional, Type
+from typing import Any
 
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.skills.portfolio.base import PortfolioBaseTool
@@ -20,11 +21,11 @@ class WalletApprovalsInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    cursor: Optional[str] = Field(
+    cursor: str | None = Field(
         description="The cursor for pagination.",
         default=None,
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The number of results per page.",
         default=DEFAULT_LIMIT,
     )
@@ -42,16 +43,16 @@ class WalletApprovals(PortfolioBaseTool):
         "Retrieve active ERC20 token approvals for the specified wallet address. "
         "This helps identify which contracts have permission to spend tokens."
     )
-    args_schema: Type[BaseModel] = WalletApprovalsInput
+    args_schema: type[BaseModel] = WalletApprovalsInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        cursor: Optional[str] = None,
-        limit: Optional[int] = DEFAULT_LIMIT,
+        cursor: str | None = None,
+        limit: int | None = DEFAULT_LIMIT,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch wallet token approvals from Moralis.
 
         Args:
@@ -69,11 +70,6 @@ class WalletApprovals(PortfolioBaseTool):
             f"wallet_approvals.py: Fetching wallet approvals with context {context}"
         )
 
-        # Get the API key from the agent's configuration
-        api_key = self.get_api_key()
-        if not api_key:
-            return {"error": "No Moralis API key provided in the configuration."}
-
         # Build query parameters
         params = {
             "chain": chain,
@@ -85,16 +81,19 @@ class WalletApprovals(PortfolioBaseTool):
             params["cursor"] = cursor
 
         # Call Moralis API
+        api_key = self.get_api_key()
+
         try:
             endpoint = f"/wallets/{address}/approvals"
             return await self._make_request(
                 method="GET", endpoint=endpoint, api_key=api_key, params=params
             )
-        except Exception as e:
+        except ToolException:
+            raise
+        except Exception as exc:  # noqa: BLE001
             logger.error(
-                f"wallet_approvals.py: Error fetching wallet approvals: {e}",
-                exc_info=True,
+                "wallet_approvals.py: Error fetching wallet approvals", exc_info=exc
             )
-            return {
-                "error": "An error occurred while fetching wallet approvals. Please try again later."
-            }
+            raise ToolException(
+                "An unexpected error occurred while fetching wallet approvals."
+            ) from exc

intentkit/skills/portfolio/wallet_defi_positions.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -31,14 +31,14 @@ class WalletDefiPositions(PortfolioBaseTool):
         "Get the DeFi positions summary of a wallet address. "
         "Returns information about liquidity positions, staking, lending, and other DeFi activities."
     )
-    args_schema: Type[BaseModel] = WalletDefiPositionsInput
+    args_schema: type[BaseModel] = WalletDefiPositionsInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch wallet DeFi positions from Moralis.
 
         Args:

intentkit/skills/portfolio/wallet_history.py

@@ -1,6 +1,7 @@
 import logging
-from typing import Any, Dict, Optional, Type
+from typing import Any
 
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.skills.portfolio.base import PortfolioBaseTool
@@ -23,39 +24,39 @@ class WalletHistoryInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The desired page size of the result.",
         default=DEFAULT_LIMIT,
     )
-    cursor: Optional[str] = Field(
+    cursor: str | None = Field(
         description="The cursor returned in the previous response (for pagination).",
         default=None,
     )
-    from_block: Optional[int] = Field(
+    from_block: int | None = Field(
         description="The minimum block number to get transactions from.",
         default=None,
     )
-    to_block: Optional[int] = Field(
+    to_block: int | None = Field(
         description="The maximum block number to get transactions from.",
         default=None,
     )
-    from_date: Optional[str] = Field(
+    from_date: str | None = Field(
         description="The start date to get transactions from (format in seconds or datestring).",
         default=None,
     )
-    to_date: Optional[str] = Field(
+    to_date: str | None = Field(
         description="The end date to get transactions from (format in seconds or datestring).",
         default=None,
     )
-    include_internal_transactions: Optional[bool] = Field(
+    include_internal_transactions: bool | None = Field(
         description="If the result should contain the internal transactions.",
         default=None,
     )
-    nft_metadata: Optional[bool] = Field(
+    nft_metadata: bool | None = Field(
         description="If the result should contain the NFT metadata.",
         default=None,
     )
-    order: Optional[str] = Field(
+    order: str | None = Field(
         description="The order of the result, in ascending (ASC) or descending (DESC).",
         default=DEFAULT_ORDER,
     )
@@ -73,23 +74,23 @@ class WalletHistory(PortfolioBaseTool):
         "Retrieve the full transaction history of a specified wallet address, including sends, "
         "receives, token and NFT transfers, and contract interactions."
     )
-    args_schema: Type[BaseModel] = WalletHistoryInput
+    args_schema: type[BaseModel] = WalletHistoryInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        limit: Optional[int] = DEFAULT_LIMIT,
-        cursor: Optional[str] = None,
-        from_block: Optional[int] = None,
-        to_block: Optional[int] = None,
-        from_date: Optional[str] = None,
-        to_date: Optional[str] = None,
-        include_internal_transactions: Optional[bool] = None,
-        nft_metadata: Optional[bool] = None,
-        order: Optional[str] = DEFAULT_ORDER,
+        limit: int | None = DEFAULT_LIMIT,
+        cursor: str | None = None,
+        from_block: int | None = None,
+        to_block: int | None = None,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        include_internal_transactions: bool | None = None,
+        nft_metadata: bool | None = None,
+        order: str | None = DEFAULT_ORDER,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch wallet transaction history from Moralis.
 
         Args:
@@ -114,11 +115,6 @@ class WalletHistory(PortfolioBaseTool):
             f"wallet_history.py: Fetching wallet history with context {context}"
         )
 
-        # Get the API key from the agent's configuration
-        api_key = self.get_api_key()
-        if not api_key:
-            return {"error": "No Moralis API key provided in the configuration."}
-
         # Build query parameters
         params = {"chain": chain, "limit": limit, "order": order}
 
@@ -139,15 +135,19 @@ class WalletHistory(PortfolioBaseTool):
             params["nft_metadata"] = nft_metadata
 
         # Call Moralis API
+        api_key = self.get_api_key()
+
         try:
             endpoint = f"/wallets/{address}/history"
             return await self._make_request(
                 method="GET", endpoint=endpoint, api_key=api_key, params=params
             )
-        except Exception as e:
+        except ToolException:
+            raise
+        except Exception as exc:  # noqa: BLE001
             logger.error(
-                f"wallet_history.py: Error fetching wallet history: {e}", exc_info=True
+                "wallet_history.py: Error fetching wallet history", exc_info=exc
             )
-            return {
-                "error": "An error occurred while fetching wallet history. Please try again later."
-            }
+            raise ToolException(
+                "An unexpected error occurred while fetching wallet history."
+            ) from exc

intentkit/skills/portfolio/wallet_net_worth.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -12,23 +12,23 @@ class WalletNetWorthInput(BaseModel):
     """Input for wallet net worth tool."""
 
     address: str = Field(description="The wallet address to calculate net worth for.")
-    chains: Optional[List[str]] = Field(
+    chains: list[str] | None = Field(
         description="The chains to query (e.g., ['eth', 'bsc', 'polygon']).",
         default=None,
     )
-    exclude_spam: Optional[bool] = Field(
+    exclude_spam: bool | None = Field(
         description="Exclude spam tokens from the result.",
         default=True,
     )
-    exclude_unverified_contracts: Optional[bool] = Field(
+    exclude_unverified_contracts: bool | None = Field(
         description="Exclude unverified contracts from the result.",
         default=True,
     )
-    max_token_inactivity: Optional[int] = Field(
+    max_token_inactivity: int | None = Field(
         description="Exclude tokens inactive for more than the given amount of days.",
         default=1,
     )
-    min_pair_side_liquidity_usd: Optional[float] = Field(
+    min_pair_side_liquidity_usd: float | None = Field(
         description="Exclude tokens with liquidity less than the specified amount in USD.",
         default=1000,
     )
@@ -46,18 +46,18 @@ class WalletNetWorth(PortfolioBaseTool):
         "Get the net worth of a wallet in USD across multiple chains. "
         "Filters out spam tokens and low-liquidity assets for more accurate results."
     )
-    args_schema: Type[BaseModel] = WalletNetWorthInput
+    args_schema: type[BaseModel] = WalletNetWorthInput
 
     async def _arun(
         self,
         address: str,
-        chains: Optional[List[str]] = None,
-        exclude_spam: Optional[bool] = True,
-        exclude_unverified_contracts: Optional[bool] = True,
-        max_token_inactivity: Optional[int] = 1,
-        min_pair_side_liquidity_usd: Optional[float] = 1000,
+        chains: list[str] | None = None,
+        exclude_spam: bool | None = True,
+        exclude_unverified_contracts: bool | None = True,
+        max_token_inactivity: int | None = 1,
+        min_pair_side_liquidity_usd: float | None = 1000,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Calculate wallet net worth from Moralis.
 
         Args:

intentkit/skills/portfolio/wallet_nfts.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -17,35 +17,35 @@ class WalletNFTsInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'base', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    format: Optional[str] = Field(
+    format: str | None = Field(
         description="The format of the token ID ('decimal' or 'hex').",
         default="decimal",
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The desired page size of the result.",
         default=DEFAULT_LIMIT,
     )
-    exclude_spam: Optional[bool] = Field(
+    exclude_spam: bool | None = Field(
         description="Should spam NFTs be excluded from the result?",
         default=True,
     )
-    token_addresses: Optional[List[str]] = Field(
+    token_addresses: list[str] | None = Field(
         description="The non-fungible token (NFT) addresses to get balances for.",
         default=None,
     )
-    cursor: Optional[str] = Field(
+    cursor: str | None = Field(
         description="The cursor returned in the previous response (for pagination).",
         default=None,
     )
-    normalize_metadata: Optional[bool] = Field(
+    normalize_metadata: bool | None = Field(
         description="The option to enable metadata normalization.",
         default=True,
     )
-    media_items: Optional[bool] = Field(
+    media_items: bool | None = Field(
         description="Should preview media data be returned?",
         default=False,
     )
-    include_prices: Optional[bool] = Field(
+    include_prices: bool | None = Field(
         description="Should NFT last sale prices be included in the result?",
         default=False,
     )
@@ -63,22 +63,22 @@ class WalletNFTs(PortfolioBaseTool):
         "Get NFTs owned by a given wallet address. Results include token details, "
         "metadata, collection information, and optionally prices."
     )
-    args_schema: Type[BaseModel] = WalletNFTsInput
+    args_schema: type[BaseModel] = WalletNFTsInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        format: Optional[str] = "decimal",
-        limit: Optional[int] = DEFAULT_LIMIT,
-        exclude_spam: Optional[bool] = True,
-        token_addresses: Optional[List[str]] = None,
-        cursor: Optional[str] = None,
-        normalize_metadata: Optional[bool] = True,
-        media_items: Optional[bool] = False,
-        include_prices: Optional[bool] = False,
+        format: str | None = "decimal",
+        limit: int | None = DEFAULT_LIMIT,
+        exclude_spam: bool | None = True,
+        token_addresses: list[str] | None = None,
+        cursor: str | None = None,
+        normalize_metadata: bool | None = True,
+        media_items: bool | None = False,
+        include_prices: bool | None = False,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch NFTs owned by a wallet from Moralis.
 
         Args:

intentkit/skills/portfolio/wallet_profitability.py

@@ -1,6 +1,7 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
+from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.skills.portfolio.base import PortfolioBaseTool
@@ -19,11 +20,11 @@ class WalletProfitabilityInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    days: Optional[str] = Field(
+    days: str | None = Field(
         description="Timeframe in days for which profitability is calculated. Options: 'all', '7', '30', '60', '90'.",
         default="all",
     )
-    token_addresses: Optional[List[str]] = Field(
+    token_addresses: list[str] | None = Field(
         description="The token addresses list to filter the result with.",
         default=None,
     )
@@ -41,16 +42,16 @@ class WalletProfitability(PortfolioBaseTool):
         "Retrieve detailed profitability breakdown for a wallet, including profit/loss per token, "
         "average buy/sell prices, and realized profits. Can be filtered by specific tokens."
     )
-    args_schema: Type[BaseModel] = WalletProfitabilityInput
+    args_schema: type[BaseModel] = WalletProfitabilityInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        days: Optional[str] = "all",
-        token_addresses: Optional[List[str]] = None,
+        days: str | None = "all",
+        token_addresses: list[str] | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch detailed wallet profitability from Moralis.
 
         Args:
@@ -68,11 +69,6 @@ class WalletProfitability(PortfolioBaseTool):
             f"wallet_profitability.py: Fetching profitability breakdown with context {context}"
         )
 
-        # Get the API key from the agent's configuration
-        api_key = self.get_api_key()
-        if not api_key:
-            return {"error": "No Moralis API key provided in the configuration."}
-
         # Build query parameters
         params = {
             "chain": chain,
@@ -84,16 +80,20 @@ class WalletProfitability(PortfolioBaseTool):
             params["token_addresses"] = token_addresses
 
         # Call Moralis API
+        api_key = self.get_api_key()
+
         try:
             endpoint = f"/wallets/{address}/profitability"
             return await self._make_request(
                 method="GET", endpoint=endpoint, api_key=api_key, params=params
             )
-        except Exception as e:
+        except ToolException:
+            raise
+        except Exception as exc:  # noqa: BLE001
             logger.error(
-                f"wallet_profitability.py: Error fetching profitability breakdown: {e}",
-                exc_info=True,
+                "wallet_profitability.py: Error fetching profitability breakdown",
+                exc_info=exc,
             )
-            return {
-                "error": "An error occurred while fetching profitability breakdown. Please try again later."
-            }
+            raise ToolException(
+                "An unexpected error occurred while fetching profitability breakdown."
+            ) from exc