intentkit 0.8.12.dev1__py3-none-any.whl → 0.8.12.dev3__py3-none-any.whl

intentkit/skills/base.py

@@ -29,7 +29,6 @@ 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
@@ -63,7 +62,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 +82,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 +96,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 +153,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(
@@ -254,7 +329,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