intentkit 0.8.11__py3-none-any.whl → 0.8.12__py3-none-any.whl

intentkit/skills/system/regenerate_agent_api_key.py

@@ -1,5 +1,7 @@
 from pydantic import BaseModel, Field
 
+from intentkit.config.config import config
+from intentkit.models.agent_data import AgentData
 from intentkit.skills.system.base import SystemBaseTool
 
 
@@ -43,11 +45,11 @@ class RegenerateAgentApiKey(SystemBaseTool):
         context = self.get_context()
         agent_id = context.agent_id
 
-        # Get agent data from skill store
-        agent_data = await self.skill_store.get_agent_data(agent_id)
+        # Get agent data directly from the model
+        agent_data = await AgentData.get(agent_id)
 
         # Get API base URL from system config
-        open_api_base_url = self.skill_store.get_system_config("open_api_base_url")
+        open_api_base_url = config.open_api_base_url
         api_endpoint = f"{open_api_base_url}/v1/chat/completions"
 
         # Check if previous API keys existed
@@ -58,7 +60,7 @@ class RegenerateAgentApiKey(SystemBaseTool):
         new_public_api_key = self._generate_public_api_key()
 
         # Save the new API keys to agent data (overwrites existing)
-        await self.skill_store.set_agent_data(
+        await AgentData.patch(
             agent_id, {"api_key": new_api_key, "api_key_public": new_public_api_key}
         )
 

intentkit/skills/tavily/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.tavily.base import TavilyBaseTool
 from intentkit.skills.tavily.tavily_extract import TavilyExtract
@@ -30,7 +29,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[TavilyBaseTool]:
     """Get all Tavily search skills.
@@ -38,7 +36,6 @@ async def get_skills(
     Args:
         config: The configuration for Tavily search skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of Tavily search skills.
@@ -55,7 +52,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_tavily_skill(name, store)
+        skill = get_tavily_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -63,28 +60,22 @@ async def get_skills(
 
 def get_tavily_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> TavilyBaseTool:
     """Get a Tavily search skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested Tavily search skill
     """
     if name == "tavily_search":
         if name not in _cache:
-            _cache[name] = TavilySearch(
-                skill_store=store,
-            )
+            _cache[name] = TavilySearch()
         return _cache[name]
     elif name == "tavily_extract":
         if name not in _cache:
-            _cache[name] = TavilyExtract(
-                skill_store=store,
-            )
+            _cache[name] = TavilyExtract()
         return _cache[name]
     else:
         logger.warning(f"Unknown Tavily skill: {name}")

intentkit/skills/tavily/base.py

@@ -3,7 +3,7 @@ from typing import Type
 from langchain_core.tools.base 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
 
 
@@ -13,16 +13,13 @@ class TavilyBaseTool(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"
-    )
 
     def get_api_key(self) -> str:
         context = self.get_context()
         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("tavily_api_key")
+            return config.tavily_api_key
         # for backward compatibility, may only have api_key in skill_config
         elif skill_config.get("api_key"):
             return skill_config.get("api_key")

intentkit/skills/tavily/tavily_extract.py

@@ -73,9 +73,8 @@ class TavilyExtract(TavilyBaseTool):
                 "rate_limit_minutes"
             ):
                 await self.user_rate_limit_by_category(
-                    context.user_id,
                     skill_config["rate_limit_number"],
-                    skill_config["rate_limit_minutes"],
+                    skill_config["rate_limit_minutes"] * 60,
                 )
 
         # Get the API key from the agent's configuration

intentkit/skills/tavily/tavily_search.py

@@ -4,6 +4,7 @@ from typing import Type
 import httpx
 from pydantic import BaseModel, Field
 
+from intentkit.config.config import config
 from intentkit.skills.tavily.base import TavilyBaseTool
 
 logger = logging.getLogger(__name__)
@@ -80,16 +81,15 @@ class TavilySearch(TavilyBaseTool):
                 "rate_limit_minutes"
             ):
                 await self.user_rate_limit_by_category(
-                    context.user_id,
                     skill_config["rate_limit_number"],
-                    skill_config["rate_limit_minutes"],
+                    skill_config["rate_limit_minutes"] * 60,
                 )
 
         # Get the API key from the agent's configuration
         if skill_config.get("api_key_provider") == "agent_owner":
             api_key = skill_config.get("api_key")
         else:
-            api_key = self.skill_store.get_system_config("tavily_api_key")
+            api_key = config.tavily_api_key
         if not api_key:
             return "Error: No Tavily API key provided in the configuration."
 

intentkit/skills/token/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.token.base import TokenBaseTool
 from intentkit.skills.token.erc20_transfers import ERC20Transfers
@@ -36,7 +35,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[TokenBaseTool]:
     """Get all Token blockchain analysis skills.
@@ -44,7 +42,6 @@ async def get_skills(
     Args:
         config: The configuration for Token skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of Token blockchain analysis skills.
@@ -65,7 +62,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_token_skill(name, store)
+        skill = get_token_skill(name)
         if skill:
             result.append(skill)
 
@@ -74,13 +71,11 @@ async def get_skills(
 
 def get_token_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> TokenBaseTool:
     """Get a Token blockchain analysis skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested Token blockchain analysis skill
@@ -90,13 +85,13 @@ def get_token_skill(
 
     skill = None
     if name == "token_price":
-        skill = TokenPrice(skill_store=store)
+        skill = TokenPrice()
     elif name == "token_erc20_transfers":
-        skill = ERC20Transfers(skill_store=store)
+        skill = ERC20Transfers()
     elif name == "token_search":
-        skill = TokenSearch(skill_store=store)
+        skill = TokenSearch()
     elif name == "token_analytics":
-        skill = TokenAnalytics(skill_store=store)
+        skill = TokenAnalytics()
     else:
         logger.warning(f"Unknown Token skill: {name}")
         return None

intentkit/skills/token/base.py

@@ -5,7 +5,7 @@ from typing import Any, Dict
 
 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,7 +33,7 @@ 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]:
         """Convert boolean values to lowercase strings for API compatibility.

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

@@ -4,7 +4,7 @@ from typing import Type
 from langchain_core.tools.base 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.utils.error import RateLimitExceeded
 
@@ -15,9 +15,6 @@ 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"
-    )
 
     def get_api_key(self) -> dict:
         context = self.get_context()
@@ -25,20 +22,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,22 +61,17 @@ 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)
 
@@ -92,9 +85,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 +94,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

@@ -42,16 +42,13 @@ class TwitterFollowUser(TwitterBaseTool):
             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

@@ -46,7 +46,6 @@ class TwitterGetMentions(TwitterBaseTool):
             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 +55,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")
@@ -113,9 +109,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

@@ -45,21 +45,16 @@ class TwitterGetTimeline(TwitterBaseTool):
             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 +96,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
 

intentkit/skills/twitter/get_user_by_username.py

@@ -43,16 +43,13 @@ class TwitterGetUserByUsername(TwitterBaseTool):
             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=60 * 24
-                )
+                await self.check_rate_limit(max_requests=5, interval=60 * 24)
 
             user_data = await client.get_user(
                 username=username,

intentkit/skills/twitter/get_user_tweets.py

@@ -59,21 +59,16 @@ class TwitterGetUserTweets(TwitterBaseTool):
             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, user_id
-            )
+            last = await self.get_agent_skill_data(user_id)
             last = last or {}
             since_id = last.get("since_id")
 
@@ -112,9 +107,7 @@ class TwitterGetUserTweets(TwitterBaseTool):
             # Update the since_id in store for the next request
             if tweets.get("meta") and tweets["meta"].get("newest_id"):
                 last["since_id"] = tweets["meta"]["newest_id"]
-                await self.skill_store.save_agent_skill_data(
-                    context.agent_id, self.name, user_id, last
-                )
+                await self.save_agent_skill_data(user_id, last)
 
             return tweets
 

intentkit/skills/twitter/like_tweet.py

@@ -40,16 +40,13 @@ class TwitterLikeTweet(TwitterBaseTool):
             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=100, interval=1440
-                )
+                await self.check_rate_limit(max_requests=100, interval=1440)
 
             # Like the tweet using tweepy client
             response = await client.like(tweet_id=tweet_id, user_auth=twitter.use_key)

intentkit/skills/twitter/post_tweet.py

@@ -5,6 +5,7 @@ from langchain_core.tools import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.clients import get_twitter_client
+from intentkit.config.config import config
 from intentkit.skills.twitter.base import TwitterBaseTool
 
 NAME = "twitter_post_tweet"
@@ -54,16 +55,13 @@ class TwitterPostTweet(TwitterBaseTool):
             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=24, interval=1440
-                )
+                await self.check_rate_limit(max_requests=24, interval=1440)
 
             media_ids = []
             image_warning = ""
@@ -71,7 +69,7 @@ class TwitterPostTweet(TwitterBaseTool):
             # Handle image upload if provided
             if image:
                 # Validate image URL - must be from system's S3 CDN
-                aws_s3_cdn_url = self.skill_store.get_system_config("aws_s3_cdn_url")
+                aws_s3_cdn_url = config.aws_s3_cdn_url
                 if aws_s3_cdn_url and image.startswith(aws_s3_cdn_url):
                     # Use the TwitterClient method to upload the image
                     media_ids = await twitter.upload_media(context.agent_id, image)