intentkit 0.8.12rc0__py3-none-any.whl → 0.8.13__py3-none-any.whl

intentkit/skills/allora/__init__.py

@@ -3,7 +3,6 @@
 import logging
 from typing import NotRequired, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.allora.base import AlloraBaseTool
 from intentkit.skills.allora.price import AlloraGetPrice
 from intentkit.skills.base import SkillConfig, SkillState
@@ -28,7 +27,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
 ) -> list[AlloraBaseTool]:
     """Get all Allora skills.
@@ -36,7 +34,6 @@ async def get_skills(
     Args:
         config: The configuration for Allora skills.
         is_private: Whether to include private skills.
-        store: The skill store for persisting data.
 
     Returns:
         A list of Allora skills.
@@ -53,7 +50,7 @@ async def get_skills(
     # Get each skill using the cached getter
     result = []
     for name in available_skills:
-        skill = get_allora_skill(name, store)
+        skill = get_allora_skill(name)
         if skill:
             result.append(skill)
     return result
@@ -61,22 +58,18 @@ async def get_skills(
 
 def get_allora_skill(
     name: str,
-    store: SkillStoreABC,
 ) -> AlloraBaseTool:
     """Get an Allora skill by name.
 
     Args:
         name: The name of the skill to get
-        store: The skill store for persisting data
 
     Returns:
         The requested Allora skill
     """
     if name == "get_price_prediction":
         if name not in _cache:
-            _cache[name] = AlloraGetPrice(
-                skill_store=store,
-            )
+            _cache[name] = AlloraGetPrice()
         return _cache[name]
     else:
         logger.warning(f"Unknown Allora skill: {name}")

intentkit/skills/allora/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
 
 base_url = "https://api.upshot.xyz/v2/allora"
@@ -15,16 +15,13 @@ class AlloraBaseTool(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("allora_api_key")
+            return config.allora_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/base.py

@@ -26,12 +26,9 @@ from pydantic import (
 )
 from pydantic.v1 import ValidationError as ValidationErrorV1
 from redis.exceptions import RedisError
-from web3 import Web3
 
 from intentkit.abstracts.graph import AgentContext
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.clients import get_wallet_provider
-from intentkit.clients.web3 import get_web3_client
 from intentkit.models.redis import get_redis
 from intentkit.models.skill import (
     AgentSkillData,
@@ -63,7 +60,6 @@ class IntentKitSkill(BaseTool):
     Will have predefined abilities.
     """
 
-    skill_store: SkillStoreABC
     # overwrite the value of BaseTool
     handle_tool_error: Optional[Union[bool, str, Callable[[ToolException], str]]] = (
         lambda e: f"tool error: {e}"
@@ -84,15 +80,12 @@ class IntentKitSkill(BaseTool):
         """Get the category of the skill."""
         raise NotImplementedError
 
-    async def user_rate_limit(
-        self, user_id: str, limit: int, minutes: int, key: str
-    ) -> None:
+    async def user_rate_limit(self, limit: int, seconds: int, key: str) -> None:
         """Check if a user has exceeded the rate limit for this skill.
 
         Args:
-            user_id: The ID of the user to check
             limit: Maximum number of requests allowed
-            minutes: Time window in minutes
+            seconds: Time window in seconds
             key: The key to use for rate limiting (e.g., skill name or category)
 
         Raises:
@@ -101,25 +94,48 @@ class IntentKitSkill(BaseTool):
         Returns:
             None: Always returns None if no exception is raised
         """
-        if not user_id:
-            return None  # No rate limiting for users without ID
+        try:
+            context = self.get_context()
+        except ValueError:
+            self.logger.info(
+                "AgentContext not available, skipping rate limit for %s",
+                key,
+            )
+            return None
+
+        user_identifier = context.user_id or context.agent_id
+        if not user_identifier:
+            return None  # No rate limiting when no identifier is available
+
+        try:
+            max_requests = int(limit)
+            window_seconds = int(seconds)
+        except (TypeError, ValueError):
+            self.logger.info(
+                "Invalid user rate limit parameters for %s: limit=%r, seconds=%r",
+                key,
+                limit,
+                seconds,
+            )
+            return None
+
+        if window_seconds <= 0 or max_requests <= 0:
+            return None
 
         try:
             redis = get_redis()
             # Create a unique key for this rate limit and user
-            rate_limit_key = f"rate_limit:{key}:{user_id}"
+            rate_limit_key = f"rate_limit:{key}:{user_identifier}"
 
             # Get the current count
             count = await redis.incr(rate_limit_key)
 
             # Set expiration if this is the first request
             if count == 1:
-                await redis.expire(
-                    rate_limit_key, minutes * 60
-                )  # Convert minutes to seconds
+                await redis.expire(rate_limit_key, window_seconds)
 
             # Check if user has exceeded the limit
-            if count > limit:
+            if count > max_requests:
                 raise RateLimitExceeded(f"Rate limit exceeded for {key}")
 
             return None
@@ -135,40 +151,97 @@ class IntentKitSkill(BaseTool):
             )
             return None
 
-    async def user_rate_limit_by_skill(
-        self, user_id: str, limit: int, minutes: int
-    ) -> None:
+    async def user_rate_limit_by_skill(self, limit: int, seconds: int) -> None:
         """Check if a user has exceeded the rate limit for this specific skill.
 
         This uses the skill name as the rate limit key.
 
         Args:
-            user_id: The ID of the user to check
             limit: Maximum number of requests allowed
-            minutes: Time window in minutes
+            seconds: Time window in seconds
 
         Raises:
             RateLimitExceeded: If the user has exceeded the rate limit
         """
-        return await self.user_rate_limit(user_id, limit, minutes, self.name)
+        return await self.user_rate_limit(limit, seconds, self.name)
 
-    async def user_rate_limit_by_category(
-        self, user_id: str, limit: int, minutes: int
-    ) -> None:
+    async def user_rate_limit_by_category(self, limit: int, seconds: int) -> None:
         """Check if a user has exceeded the rate limit for this skill category.
 
         This uses the skill category as the rate limit key, which means the limit
         is shared across all skills in the same category.
 
         Args:
-            user_id: The ID of the user to check
             limit: Maximum number of requests allowed
-            minutes: Time window in minutes
+            seconds: Time window in seconds
 
         Raises:
             RateLimitExceeded: If the user has exceeded the rate limit
         """
-        return await self.user_rate_limit(user_id, limit, minutes, self.category)
+        return await self.user_rate_limit(limit, seconds, self.category)
+
+    async def global_rate_limit(self, limit: int, seconds: int, key: str) -> None:
+        """Check if a global rate limit has been exceeded for a given key.
+
+        Args:
+            limit: Maximum number of requests allowed
+            seconds: Time window in seconds
+            key: The key to use for rate limiting (e.g., skill name or category)
+
+        Raises:
+            RateLimitExceeded: If the global limit has been exceeded
+
+        Returns:
+            None: Always returns None if no exception is raised
+        """
+        try:
+            max_requests = int(limit)
+            window_seconds = int(seconds)
+        except (TypeError, ValueError):
+            self.logger.info(
+                "Invalid global rate limit parameters for %s: limit=%r, seconds=%r",
+                key,
+                limit,
+                seconds,
+            )
+            return None
+
+        if window_seconds <= 0 or max_requests <= 0:
+            return None
+
+        try:
+            redis = get_redis()
+            rate_limit_key = f"rate_limit:{key}"
+
+            count = await redis.incr(rate_limit_key)
+
+            if count == 1:
+                await redis.expire(rate_limit_key, window_seconds)
+
+            if count > max_requests:
+                raise RateLimitExceeded(f"Global rate limit exceeded for {key}")
+
+            return None
+
+        except RuntimeError:
+            self.logger.info(
+                "Redis not initialized, skipping global rate limit for %s",
+                key,
+            )
+            return None
+        except RedisError as e:
+            self.logger.info(
+                f"Redis error in global rate limiting: {e}, skipping rate limit for {key}"
+            )
+            return None
+
+    async def global_rate_limit_by_skill(self, limit: int, seconds: int) -> None:
+        """Apply a global rate limit scoped to this specific skill."""
+        return await self.global_rate_limit(limit, seconds, self.name)
+
+    async def global_rate_limit_by_category(self, limit: int, seconds: int) -> None:
+        """Apply a global rate limit scoped to this skill category."""
+        return await self.global_rate_limit(limit, seconds, self.category)
 
     def _run(self, *args: Any, **kwargs: Any) -> Any:
         raise NotImplementedError(
@@ -182,14 +255,6 @@ class IntentKitSkill(BaseTool):
             raise ValueError("No AgentContext found")
         return runtime.context
 
-    def web3_client(self) -> Web3:
-        """Get a Web3 client for the skill."""
-        context = self.get_context()
-        agent = context.agent
-        network_id = agent.network_id
-
-        return get_web3_client(network_id)
-
     async def get_agent_skill_data(
         self,
         key: str,
@@ -254,7 +319,6 @@ class IntentKitSkill(BaseTool):
 
 async def get_agentkit_actions(
     agent_id: str,
-    _store: SkillStoreABC,
     provider_factories: Sequence[Callable[[], object]],
     *,
     agent: Optional["Agent"] = None,

intentkit/skills/basename/__init__.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Optional, TypedDict
 
 from coinbase_agentkit import basename_action_provider
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import (
     SkillConfig,
     SkillState,
@@ -30,7 +29,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     agent_id: str,
     agent: Optional["Agent"] = None,
     **_,
@@ -45,7 +43,7 @@ async def get_skills(
             available_skills.append(skill_name)
 
     actions = await get_agentkit_actions(
-        agent_id, store, [basename_action_provider], agent=agent
+        agent_id, [basename_action_provider], agent=agent
     )
     tools: list[BasenameBaseTool] = []
     for skill in available_skills:

intentkit/skills/carv/__init__.py

@@ -1,121 +1,116 @@
-import logging
-from typing import List, Literal, Optional, TypedDict
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import SkillConfig, SkillState
-from intentkit.skills.carv.base import CarvBaseTool
-from intentkit.skills.carv.fetch_news import FetchNewsTool
-from intentkit.skills.carv.onchain_query import OnchainQueryTool
-from intentkit.skills.carv.token_info_and_price import TokenInfoAndPriceTool
-
-logger = logging.getLogger(__name__)
-
-
-_cache: dict[str, CarvBaseTool] = {}
-
-_SKILL_NAME_TO_CLASS_MAP: dict[str, type[CarvBaseTool]] = {
-    "onchain_query": OnchainQueryTool,
-    "token_info_and_price": TokenInfoAndPriceTool,
-    "fetch_news": FetchNewsTool,
-}
-
-
-class SkillStates(TypedDict):
-    onchain_query: SkillState
-    token_info_and_price: SkillState
-    fetch_news: SkillState
-
-
-class Config(SkillConfig):
-    enabled: bool
-    states: SkillStates  # type: ignore
-    api_key_provider: Optional[Literal["agent_owner", "platform"]]
-
-    # conditionally required
-    api_key: Optional[str]
-
-    # optional
-    rate_limit_number: Optional[int]
-    rate_limit_minutes: Optional[int]
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,
-) -> list[CarvBaseTool]:
-    """
-    Factory function to create and return CARV skill tools based on the provided configuration.
-
-    Args:
-        config: The configuration object for the CARV skill.
-        is_private: A boolean indicating whether the request is from a private context.
-        store: An instance of `SkillStoreABC`.
-
-    Returns:
-        A list of `CarvBaseTool` instances.
-    """
-    # Check if the entire category is disabled first
-    if not config.get("enabled", False):
-        return []
-
-    available_skills: List[CarvBaseTool] = []
-    skill_states = config.get("states", {})
-
-    # Iterate through all known skills defined in the map
-    for skill_name in _SKILL_NAME_TO_CLASS_MAP:
-        state = skill_states.get(
-            skill_name, "disabled"
-        )  # Default to disabled if not in config
-
-        if state == "disabled":
-            continue
-        elif state == "public" or (state == "private" and is_private):
-            # If enabled, get the skill instance using the factory function
-            skill_instance = get_carv_skill(skill_name, store)
-            if skill_instance:
-                available_skills.append(skill_instance)
-            else:
-                logger.warning(f"Could not instantiate known skill: {skill_name}")
-
-    return available_skills
-
-
-def get_carv_skill(
-    name: str,
-    store: SkillStoreABC,
-) -> Optional[CarvBaseTool]:
-    """
-    Factory function to retrieve a cached CARV skill instance by name.
-
-    Args:
-        name: The name of the CARV skill to retrieve.
-        store: An instance of `SkillStoreABC`.
-
-    Returns:
-        The requested `CarvBaseTool` instance if found and enabled, otherwise None.
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    # Get the class from the map
-    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
-
-    if skill_class:
-        try:
-            # Instantiate the skill and add to cache
-            instance = skill_class(skill_store=store)  # type: ignore
-            _cache[name] = instance
-            return instance
-        except Exception as e:
-            logger.error(
-                f"Failed to instantiate Carv skill '{name}': {e}", exc_info=True
-            )
-            return None  # Failed to instantiate
-    else:
-        # This handles cases where a name might be in config but not in our map
-        logger.warning(f"Attempted to get unknown Carv skill: {name}")
-        return None
+import logging
+from typing import List, Literal, Optional, TypedDict
+
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.carv.base import CarvBaseTool
+from intentkit.skills.carv.fetch_news import FetchNewsTool
+from intentkit.skills.carv.onchain_query import OnchainQueryTool
+from intentkit.skills.carv.token_info_and_price import TokenInfoAndPriceTool
+
+logger = logging.getLogger(__name__)
+
+
+_cache: dict[str, CarvBaseTool] = {}
+
+_SKILL_NAME_TO_CLASS_MAP: dict[str, type[CarvBaseTool]] = {
+    "onchain_query": OnchainQueryTool,
+    "token_info_and_price": TokenInfoAndPriceTool,
+    "fetch_news": FetchNewsTool,
+}
+
+
+class SkillStates(TypedDict):
+    onchain_query: SkillState
+    token_info_and_price: SkillState
+    fetch_news: SkillState
+
+
+class Config(SkillConfig):
+    enabled: bool
+    states: SkillStates  # type: ignore
+    api_key_provider: Optional[Literal["agent_owner", "platform"]]
+
+    # conditionally required
+    api_key: Optional[str]
+
+    # optional
+    rate_limit_number: Optional[int]
+    rate_limit_minutes: Optional[int]
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,
+) -> list[CarvBaseTool]:
+    """
+    Factory function to create and return CARV skill tools based on the provided configuration.
+
+    Args:
+        config: The configuration object for the CARV skill.
+        is_private: A boolean indicating whether the request is from a private context.
+
+    Returns:
+        A list of `CarvBaseTool` instances.
+    """
+    # Check if the entire category is disabled first
+    if not config.get("enabled", False):
+        return []
+
+    available_skills: List[CarvBaseTool] = []
+    skill_states = config.get("states", {})
+
+    # Iterate through all known skills defined in the map
+    for skill_name in _SKILL_NAME_TO_CLASS_MAP:
+        state = skill_states.get(
+            skill_name, "disabled"
+        )  # Default to disabled if not in config
+
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            # If enabled, get the skill instance using the factory function
+            skill_instance = get_carv_skill(skill_name)
+            if skill_instance:
+                available_skills.append(skill_instance)
+            else:
+                logger.warning(f"Could not instantiate known skill: {skill_name}")
+
+    return available_skills
+
+
+def get_carv_skill(
+    name: str,
+) -> Optional[CarvBaseTool]:
+    """
+    Factory function to retrieve a cached CARV skill instance by name.
+
+    Args:
+        name: The name of the CARV skill to retrieve.
+
+    Returns:
+        The requested `CarvBaseTool` instance if found and enabled, otherwise None.
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    # Get the class from the map
+    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
+
+    if skill_class:
+        try:
+            # Instantiate the skill and add to cache
+            instance = skill_class()  # type: ignore
+            _cache[name] = instance
+            return instance
+        except Exception as e:
+            logger.error(
+                f"Failed to instantiate Carv skill '{name}': {e}", exc_info=True
+            )
+            return None  # Failed to instantiate
+    else:
+        # This handles cases where a name might be in config but not in our map
+        logger.warning(f"Attempted to get unknown Carv skill: {name}")
+        return None