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

intentkit/skills/token/base.py

@@ -1,11 +1,11 @@
 """Base class for token-related skills."""
 
 import logging
-from typing import Any, Dict
+from typing import Any
 
 import aiohttp
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
 from intentkit.skills.token.constants import MORALIS_API_BASE_URL
 
@@ -19,10 +19,6 @@ class TokenBaseTool(IntentKitSkill):
     including making HTTP requests to the Moralis API.
     """
 
-    def __init__(self, skill_store: SkillStoreABC = None):
-        """Initialize the token tool with a skill store."""
-        super().__init__(skill_store=skill_store)
-
     @property
     def category(self) -> str:
         return "token"
@@ -37,9 +33,9 @@ class TokenBaseTool(IntentKitSkill):
         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")
+        return config.moralis_api_key
 
-    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:
@@ -64,9 +60,9 @@ class TokenBaseTool(IntentKitSkill):
         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:

intentkit/skills/token/erc20_transfers.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -19,35 +19,35 @@ class ERC20TransfersInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    contract_addresses: Optional[List[str]] = Field(
+    contract_addresses: list[str] | None = Field(
         description="List of contract addresses of transfers to filter by.",
         default=None,
     )
-    from_block: Optional[int] = Field(
+    from_block: int | None = Field(
         description="The minimum block number from which to get the transactions.",
         default=None,
     )
-    to_block: Optional[int] = Field(
+    to_block: int | None = Field(
         description="The maximum block number from which to get the transactions.",
         default=None,
     )
-    from_date: Optional[str] = Field(
+    from_date: str | None = Field(
         description="The start date from which to get the transactions (any format accepted by momentjs).",
         default=None,
     )
-    to_date: Optional[str] = Field(
+    to_date: str | None = Field(
         description="Get the transactions up to this date (any format accepted by momentjs).",
         default=None,
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The desired page size of the result.",
         default=DEFAULT_LIMIT,
     )
-    order: Optional[str] = Field(
+    order: str | None = Field(
         description="The order of the result, in ascending (ASC) or descending (DESC).",
         default=DEFAULT_ORDER,
     )
-    cursor: Optional[str] = Field(
+    cursor: str | None = Field(
         description="The cursor returned in the previous response (for pagination).",
         default=None,
     )
@@ -65,22 +65,22 @@ class ERC20Transfers(TokenBaseTool):
         "Get ERC20 token transactions for a wallet address, ordered by block number. "
         "Returns transaction details, token information, and wallet interactions."
     )
-    args_schema: Type[BaseModel] = ERC20TransfersInput
+    args_schema: type[BaseModel] = ERC20TransfersInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        contract_addresses: Optional[List[str]] = None,
-        from_block: Optional[int] = None,
-        to_block: Optional[int] = None,
-        from_date: Optional[str] = None,
-        to_date: Optional[str] = None,
-        limit: Optional[int] = DEFAULT_LIMIT,
-        order: Optional[str] = DEFAULT_ORDER,
-        cursor: Optional[str] = None,
+        contract_addresses: list[str] | None = None,
+        from_block: int | None = None,
+        to_block: int | None = None,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        limit: int | None = DEFAULT_LIMIT,
+        order: str | None = DEFAULT_ORDER,
+        cursor: str | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch ERC20 token transfers for a wallet from Moralis.
 
         Args:

intentkit/skills/token/schema.json

@@ -5,11 +5,8 @@
   "type": "object",
   "x-icon": "https://ai.service.crestal.dev/skills/portfolio/moralis.png",
   "x-tags": [
-    "Blockchain",
-    "Web3",
-    "Crypto",
-    "Token",
-    "DeFi"
+    "Analytics",
+    "Crypto"
   ],
   "properties": {
     "enabled": {
@@ -138,4 +135,4 @@
     }
   },
   "additionalProperties": true
-}
+}

intentkit/skills/token/token_analytics.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 TokenAnalytics(TokenBaseTool):
         "Get analytics for a token by token address. "
         "Returns trading volumes, number of buyers/sellers, and liquidity information over various time periods."
     )
-    args_schema: Type[BaseModel] = TokenAnalyticsInput
+    args_schema: type[BaseModel] = TokenAnalyticsInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch token analytics from Moralis.
 
         Args:

intentkit/skills/token/token_price.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -19,23 +19,23 @@ class TokenPriceInput(BaseModel):
         description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
         default=DEFAULT_CHAIN,
     )
-    include: Optional[str] = Field(
+    include: str | None = Field(
         description="If the result should contain the 24hr percent change (use 'percent_change').",
         default=None,
     )
-    exchange: Optional[str] = Field(
+    exchange: str | None = Field(
         description="The factory name or address of the token exchange.",
         default=None,
     )
-    to_block: Optional[int] = Field(
+    to_block: int | None = Field(
         description="The block number from which the token price should be checked.",
         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[int] = Field(
+    min_pair_side_liquidity_usd: int | None = Field(
         description="Exclude tokens with liquidity less than the specified amount in USD.",
         default=None,
     )
@@ -53,19 +53,19 @@ class TokenPrice(TokenBaseTool):
         "Get the token price denominated in the blockchain's native token and USD for a given token contract address. "
         "Returns price, token information and exchange data."
     )
-    args_schema: Type[BaseModel] = TokenPriceInput
+    args_schema: type[BaseModel] = TokenPriceInput
 
     async def _arun(
         self,
         address: str,
         chain: str = DEFAULT_CHAIN,
-        include: Optional[str] = None,
-        exchange: Optional[str] = None,
-        to_block: Optional[int] = None,
-        max_token_inactivity: Optional[int] = None,
-        min_pair_side_liquidity_usd: Optional[int] = None,
+        include: str | None = None,
+        exchange: str | None = None,
+        to_block: int | None = None,
+        max_token_inactivity: int | None = None,
+        min_pair_side_liquidity_usd: int | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Fetch token price from Moralis.
 
         Args:

intentkit/skills/token/token_search.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -14,15 +14,15 @@ class TokenSearchInput(BaseModel):
     query: str = Field(
         description="Search query - can be token address, token name or token symbol."
     )
-    chains: Optional[List[str]] = Field(
+    chains: list[str] | None = Field(
         description="The chain(s) to query (e.g., 'eth', 'bsc', 'polygon').",
         default=None,
     )
-    limit: Optional[int] = Field(
+    limit: int | None = Field(
         description="The desired page size of the result.",
         default=None,
     )
-    is_verified_contract: Optional[bool] = Field(
+    is_verified_contract: bool | None = Field(
         description="Whether the contract is verified.",
         default=None,
     )
@@ -44,16 +44,16 @@ class TokenSearch(TokenBaseTool):
         "Returns token information including price, market cap, and security information. "
         "NOTE: This is a premium endpoint that requires a Moralis Business plan."
     )
-    args_schema: Type[BaseModel] = TokenSearchInput
+    args_schema: type[BaseModel] = TokenSearchInput
 
     async def _arun(
         self,
         query: str,
-        chains: Optional[List[str]] = None,
-        limit: Optional[int] = None,
-        is_verified_contract: Optional[bool] = None,
+        chains: list[str] | None = None,
+        limit: int | None = None,
+        is_verified_contract: bool | None = None,
         **kwargs,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Search for tokens using Moralis.
 
         Args:

intentkit/skills/twitter/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.clients import TwitterClientConfig
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.twitter.base import TwitterBaseTool
@@ -46,7 +45,6 @@ class Config(SkillConfig, TwitterClientConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[TwitterBaseTool]:
     """Get all Twitter skills."""
@@ -62,7 +60,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_twitter_skill(name, store)
+        skill = get_twitter_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -70,76 +68,54 @@ async def get_skills(
 
 def get_twitter_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> TwitterBaseTool:
     """Get a Twitter skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested Twitter skill
     """
     if name == "get_mentions":
         if name not in _cache:
-            _cache[name] = TwitterGetMentions(
-                skill_store=store,
-            )
+            _cache[name] = TwitterGetMentions()
         return _cache[name]
     elif name == "post_tweet":
         if name not in _cache:
-            _cache[name] = TwitterPostTweet(
-                skill_store=store,
-            )
+            _cache[name] = TwitterPostTweet()
         return _cache[name]
     elif name == "reply_tweet":
         if name not in _cache:
-            _cache[name] = TwitterReplyTweet(
-                skill_store=store,
-            )
+            _cache[name] = TwitterReplyTweet()
         return _cache[name]
     elif name == "get_timeline":
         if name not in _cache:
-            _cache[name] = TwitterGetTimeline(
-                skill_store=store,
-            )
+            _cache[name] = TwitterGetTimeline()
         return _cache[name]
     elif name == "follow_user":
         if name not in _cache:
-            _cache[name] = TwitterFollowUser(
-                skill_store=store,
-            )
+            _cache[name] = TwitterFollowUser()
         return _cache[name]
     elif name == "like_tweet":
         if name not in _cache:
-            _cache[name] = TwitterLikeTweet(
-                skill_store=store,
-            )
+            _cache[name] = TwitterLikeTweet()
         return _cache[name]
     elif name == "retweet":
         if name not in _cache:
-            _cache[name] = TwitterRetweet(
-                skill_store=store,
-            )
+            _cache[name] = TwitterRetweet()
         return _cache[name]
     elif name == "search_tweets":
         if name not in _cache:
-            _cache[name] = TwitterSearchTweets(
-                skill_store=store,
-            )
+            _cache[name] = TwitterSearchTweets()
         return _cache[name]
     elif name == "get_user_by_username":
         if name not in _cache:
-            _cache[name] = TwitterGetUserByUsername(
-                skill_store=store,
-            )
+            _cache[name] = TwitterGetUserByUsername()
         return _cache[name]
     elif name == "get_user_tweets":
         if name not in _cache:
-            _cache[name] = TwitterGetUserTweets(
-                skill_store=store,
-            )
+            _cache[name] = TwitterGetUserTweets()
         return _cache[name]
     else:
         logger.warning(f"Unknown Twitter skill: {name}")

intentkit/skills/twitter/base.py

@@ -1,12 +1,11 @@
-from datetime import datetime, timedelta, timezone
-from typing import Type
+from datetime import UTC, datetime, timedelta
 
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.exception import RateLimitExceeded
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
+from intentkit.utils.error import RateLimitExceeded
 
 
 class TwitterBaseTool(IntentKitSkill):
@@ -14,10 +13,7 @@ class TwitterBaseTool(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]
 
     def get_api_key(self) -> dict:
         context = self.get_context()
@@ -25,20 +21,21 @@ class TwitterBaseTool(IntentKitSkill):
         api_key_provider = skill_config.get("api_key_provider")
         if api_key_provider == "platform":
             # Return platform keys (these need to be added to config.py)
-            return {
-                "consumer_key": self.skill_store.get_system_config(
-                    "twitter_consumer_key"
-                ),
-                "consumer_secret": self.skill_store.get_system_config(
-                    "twitter_consumer_secret"
-                ),
-                "access_token": self.skill_store.get_system_config(
-                    "twitter_access_token"
-                ),
-                "access_token_secret": self.skill_store.get_system_config(
-                    "twitter_access_token_secret"
+            platform_keys = {
+                "consumer_key": getattr(config, "twitter_consumer_key", None),
+                "consumer_secret": getattr(config, "twitter_consumer_secret", None),
+                "access_token": getattr(config, "twitter_access_token", None),
+                "access_token_secret": getattr(
+                    config, "twitter_access_token_secret", None
                 ),
             }
+            missing = [key for key, value in platform_keys.items() if not value]
+            if missing:
+                raise ToolException(
+                    "Twitter platform API keys are not configured: "
+                    + ", ".join(missing)
+                )
+            return platform_keys
         # for backward compatibility or agent_owner provider
         elif api_key_provider == "agent_owner":
             required_keys = [
@@ -63,24 +60,19 @@ class TwitterBaseTool(IntentKitSkill):
     def category(self) -> str:
         return "twitter"
 
-    async def check_rate_limit(
-        self, agent_id: str, max_requests: int = 1, interval: int = 15
-    ) -> None:
+    async def check_rate_limit(self, max_requests: int = 1, interval: int = 15) -> None:
         """Check if the rate limit has been exceeded.
 
         Args:
-            agent_id: The ID of the agent.
             max_requests: Maximum number of requests allowed within the rate limit window.
             interval: Time interval in minutes for the rate limit window.
 
         Raises:
             RateLimitExceeded: If the rate limit has been exceeded.
         """
-        rate_limit = await self.skill_store.get_agent_skill_data(
-            agent_id, self.name, "rate_limit"
-        )
+        rate_limit = await self.get_agent_skill_data("rate_limit")
 
-        current_time = datetime.now(tz=timezone.utc)
+        current_time = datetime.now(tz=UTC)
 
         if (
             rate_limit
@@ -92,9 +84,7 @@ class TwitterBaseTool(IntentKitSkill):
                 raise RateLimitExceeded("Rate limit exceeded")
 
             rate_limit["count"] += 1
-            await self.skill_store.save_agent_skill_data(
-                agent_id, self.name, "rate_limit", rate_limit
-            )
+            await self.save_agent_skill_data("rate_limit", rate_limit)
 
             return
 
@@ -103,7 +93,5 @@ class TwitterBaseTool(IntentKitSkill):
             "count": 1,
             "reset_time": (current_time + timedelta(minutes=interval)).isoformat(),
         }
-        await self.skill_store.save_agent_skill_data(
-            agent_id, self.name, "rate_limit", new_rate_limit
-        )
+        await self.save_agent_skill_data("rate_limit", new_rate_limit)
         return

intentkit/skills/twitter/follow_user.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Type
 
 from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
@@ -34,24 +33,21 @@ class TwitterFollowUser(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterFollowUserInput
+    args_schema: type[BaseModel] = TwitterFollowUserInput
 
     async def _arun(self, user_id: str, **kwargs) -> bool:
+        context = self.get_context()
         try:
-            context = self.get_context()
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=5, interval=15
-                )
+                await self.check_rate_limit(max_requests=5, interval=15)
 
             # Follow the user using tweepy client
             response = await client.follow_user(

intentkit/skills/twitter/get_mentions.py

@@ -1,6 +1,5 @@
 import logging
-from datetime import datetime, timedelta, timezone
-from typing import Type
+from datetime import UTC, datetime, timedelta
 
 from langchain_core.tools import ToolException
 from pydantic import BaseModel
@@ -38,15 +37,14 @@ class TwitterGetMentions(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterGetMentionsInput
+    args_schema: type[BaseModel] = TwitterGetMentionsInput
 
     async def _arun(self, **kwargs) -> list[Tweet]:
+        context = self.get_context()
         try:
-            context = self.get_context()
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
@@ -56,15 +54,12 @@ class TwitterGetMentions(TwitterBaseTool):
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
                 await self.check_rate_limit(
-                    context.agent_id,
                     max_requests=1,
                     interval=15,
                 )
 
             # get since id from store
-            last = await self.skill_store.get_agent_skill_data(
-                context.agent_id, self.name, "last"
-            )
+            last = await self.get_agent_skill_data("last")
             last = last or {}
             max_results = 10
             since_id = last.get("since_id")
@@ -72,7 +67,7 @@ class TwitterGetMentions(TwitterBaseTool):
                 max_results = 30
 
             # Always get mentions for the last day
-            start_time = datetime.now(tz=timezone.utc) - timedelta(days=1)
+            start_time = datetime.now(tz=UTC) - timedelta(days=1)
 
             user_id = twitter.self_id
             if not user_id:
@@ -113,9 +108,7 @@ class TwitterGetMentions(TwitterBaseTool):
             # Update since_id in store
             if mentions.get("meta") and mentions["meta"].get("newest_id"):
                 last["since_id"] = mentions["meta"].get("newest_id")
-                await self.skill_store.save_agent_skill_data(
-                    context.agent_id, self.name, "last", last
-                )
+                await self.save_agent_skill_data("last", last)
 
             return mentions
 

intentkit/skills/twitter/get_timeline.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Type
 
 from pydantic import BaseModel
 
@@ -34,32 +33,27 @@ class TwitterGetTimeline(TwitterBaseTool):
 
     name: str = NAME
     description: str = PROMPT
-    args_schema: Type[BaseModel] = TwitterGetTimelineInput
+    args_schema: type[BaseModel] = TwitterGetTimelineInput
 
     async def _arun(self, **kwargs):
+        context = self.get_context()
         try:
             # Ensure max_results is an integer
             max_results = 10
 
-            context = self.get_context()
             skill_config = context.agent.skill_config(self.category)
             twitter = get_twitter_client(
                 agent_id=context.agent_id,
-                skill_store=self.skill_store,
                 config=skill_config,
             )
             client = await twitter.get_client()
 
             # Check rate limit only when not using OAuth
             if not twitter.use_key:
-                await self.check_rate_limit(
-                    context.agent_id, max_requests=1, interval=15
-                )
+                await self.check_rate_limit(max_requests=1, interval=15)
 
             # get since id from store
-            last = await self.skill_store.get_agent_skill_data(
-                context.agent_id, self.name, "last"
-            )
+            last = await self.get_agent_skill_data("last")
             last = last or {}
             since_id = last.get("since_id")
 
@@ -101,9 +95,7 @@ class TwitterGetTimeline(TwitterBaseTool):
             # Update the since_id in store for the next request
             if timeline.get("meta") and timeline["meta"].get("newest_id"):
                 last["since_id"] = timeline["meta"]["newest_id"]
-                await self.skill_store.save_agent_skill_data(
-                    context.agent_id, self.name, "last", last
-                )
+                await self.save_agent_skill_data("last", last)
 
             return timeline