intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/token/token_analytics.py

@@ -0,0 +1,81 @@
+import logging
+from typing import Any, Dict, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.token.base import TokenBaseTool
+from intentkit.skills.token.constants import DEFAULT_CHAIN
+
+logger = logging.getLogger(__name__)
+
+
+class TokenAnalyticsInput(BaseModel):
+    """Input for token analytics tool."""
+
+    address: str = Field(description="The token address to get analytics for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+
+
+class TokenAnalytics(TokenBaseTool):
+    """Tool for retrieving token analytics using Moralis.
+
+    This tool uses Moralis' API to fetch analytics for a token by token address,
+    including trading volume, buyer/seller data, and liquidity information.
+    """
+
+    name: str = "token_analytics"
+    description: str = (
+        "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
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch token analytics from Moralis.
+
+        Args:
+            address: The token address
+            chain: The blockchain to query
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing token analytics data
+        """
+        context = self.context_from_config(config)
+        if context is None:
+            logger.error("Context is None, cannot retrieve API key")
+            return {
+                "error": "Cannot retrieve API key. Please check agent configuration."
+            }
+
+        # Get the API key
+        api_key = self.get_api_key(context)
+
+        if not api_key:
+            logger.error("No Moralis API key available")
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {"chain": chain}
+
+        # Call Moralis API
+        try:
+            endpoint = f"/tokens/{address}/analytics"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(f"Error fetching token analytics: {e}")
+            return {
+                "error": f"An error occurred while fetching token analytics: {str(e)}. Please try again later."
+            }

intentkit/skills/token/token_price.py

@@ -0,0 +1,132 @@
+import logging
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.token.base import TokenBaseTool
+from intentkit.skills.token.constants import DEFAULT_CHAIN
+
+logger = logging.getLogger(__name__)
+
+
+class TokenPriceInput(BaseModel):
+    """Input for token price tool."""
+
+    address: str = Field(
+        description="The address of the token contract to get price for."
+    )
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    include: Optional[str] = Field(
+        description="If the result should contain the 24hr percent change (use 'percent_change').",
+        default=None,
+    )
+    exchange: Optional[str] = Field(
+        description="The factory name or address of the token exchange.",
+        default=None,
+    )
+    to_block: Optional[int] = Field(
+        description="The block number from which the token price should be checked.",
+        default=None,
+    )
+    max_token_inactivity: Optional[int] = Field(
+        description="Exclude tokens inactive for more than the given amount of days.",
+        default=None,
+    )
+    min_pair_side_liquidity_usd: Optional[int] = Field(
+        description="Exclude tokens with liquidity less than the specified amount in USD.",
+        default=None,
+    )
+
+
+class TokenPrice(TokenBaseTool):
+    """Tool for retrieving ERC20 token prices using Moralis.
+
+    This tool uses Moralis' API to fetch the token price denominated in the blockchain's native token
+    and USD for a given token contract address.
+    """
+
+    name: str = "token_price"
+    description: str = (
+        "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
+
+    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,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch token price from Moralis.
+
+        Args:
+            address: The token contract address
+            chain: The blockchain to query
+            include: Include 24hr percent change
+            exchange: The token exchange factory name or address
+            to_block: Block number to check price from
+            max_token_inactivity: Max days of inactivity to exclude tokens
+            min_pair_side_liquidity_usd: Min liquidity in USD to include
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing token price data
+        """
+        # Extract context from config
+        context = self.context_from_config(config)
+
+        if context is None:
+            logger.error("Context is None, cannot retrieve API key")
+            return {
+                "error": "Cannot retrieve API key. Please check agent configuration."
+            }
+
+        # Get the API key
+        api_key = self.get_api_key(context)
+
+        if not api_key:
+            logger.error("No Moralis API key available")
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {"chain": chain}
+
+        # Add optional parameters if they exist
+        if include:
+            params["include"] = include
+        if exchange:
+            params["exchange"] = exchange
+        if to_block:
+            params["to_block"] = to_block
+        if max_token_inactivity:
+            params["max_token_inactivity"] = max_token_inactivity
+        if min_pair_side_liquidity_usd:
+            params["min_pair_side_liquidity_usd"] = min_pair_side_liquidity_usd
+
+        # Call Moralis API
+        try:
+            endpoint = f"/erc20/{address}/price"
+            response = await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+
+            if "error" in response:
+                logger.error(f"API returned error: {response.get('error')}")
+
+            return response
+        except Exception as e:
+            logger.error(f"Error fetching token price: {e}")
+            return {
+                "error": f"An error occurred while fetching token price: {str(e)}. Please try again later."
+            }

intentkit/skills/token/token_search.py

@@ -0,0 +1,121 @@
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.token.base import TokenBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class TokenSearchInput(BaseModel):
+    """Input for token search tool."""
+
+    query: str = Field(
+        description="Search query - can be token address, token name or token symbol."
+    )
+    chains: Optional[List[str]] = Field(
+        description="The chain(s) to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=None,
+    )
+    limit: Optional[int] = Field(
+        description="The desired page size of the result.",
+        default=None,
+    )
+    is_verified_contract: Optional[bool] = Field(
+        description="Whether the contract is verified.",
+        default=None,
+    )
+
+
+class TokenSearch(TokenBaseTool):
+    """Tool for searching tokens using Moralis.
+
+    This tool uses Moralis' premium API to search for tokens based on contract address,
+    token name or token symbol.
+
+    NOTE: To use this API, you will need an API key associated with a Moralis account
+    on the Business plan or a custom Enterprise plan.
+    """
+
+    name: str = "token_search"
+    description: str = (
+        "Search for tokens based on contract address, token name or token symbol. "
+        "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
+
+    async def _arun(
+        self,
+        query: str,
+        chains: Optional[List[str]] = None,
+        limit: Optional[int] = None,
+        is_verified_contract: Optional[bool] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Search for tokens using Moralis.
+
+        Args:
+            query: Search query (address, name, or symbol)
+            chains: The blockchains to query
+            limit: Number of results
+            is_verified_contract: Filter for verified contracts
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing token search results
+        """
+        # Extract context from config
+        context = self.context_from_config(config)
+        if context is None:
+            logger.error("Context is None, cannot retrieve API key")
+            return {
+                "error": "Cannot retrieve API key. Please check agent configuration."
+            }
+
+        # Get the API key
+        api_key = self.get_api_key(context)
+
+        if not api_key:
+            logger.error("No Moralis API key available")
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {"query": query}
+
+        # Add optional parameters if they exist
+        if chains:
+            params["chains"] = ",".join(chains)
+        if limit:
+            params["limit"] = limit
+        if is_verified_contract is not None:
+            params["isVerifiedContract"] = is_verified_contract
+
+        # Call Moralis API
+        try:
+            endpoint = "/tokens/search"
+            result = await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+
+            # Add premium notice if there's an error that might be related to plan limits
+            if "error" in result and "403" in str(result.get("error", "")):
+                logger.error("Received 403 error - likely a plan limitation")
+                result["notice"] = (
+                    "This API requires a Moralis Business plan or Enterprise plan. "
+                    "Please ensure your API key is associated with the appropriate plan."
+                )
+
+            return result
+        except Exception as e:
+            logger.error(f"Error searching for tokens: {e}")
+            return {
+                "error": f"An error occurred while searching for tokens: {str(e)}. Please try again later.",
+                "notice": (
+                    "This API requires a Moralis Business plan or Enterprise plan. "
+                    "Please ensure your API key is associated with the appropriate plan."
+                ),
+            }

intentkit/skills/twitter/__init__.py

@@ -0,0 +1,146 @@
+"""Twitter skills."""
+
+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
+from intentkit.skills.twitter.follow_user import TwitterFollowUser
+from intentkit.skills.twitter.get_mentions import TwitterGetMentions
+from intentkit.skills.twitter.get_timeline import TwitterGetTimeline
+from intentkit.skills.twitter.get_user_by_username import TwitterGetUserByUsername
+from intentkit.skills.twitter.get_user_tweets import TwitterGetUserTweets
+from intentkit.skills.twitter.like_tweet import TwitterLikeTweet
+from intentkit.skills.twitter.post_tweet import TwitterPostTweet
+from intentkit.skills.twitter.reply_tweet import TwitterReplyTweet
+from intentkit.skills.twitter.retweet import TwitterRetweet
+from intentkit.skills.twitter.search_tweets import TwitterSearchTweets
+
+# we cache skills in system level, because they are stateless
+_cache: dict[str, TwitterBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    get_mentions: SkillState
+    post_tweet: SkillState
+    reply_tweet: SkillState
+    get_timeline: SkillState
+    get_user_by_username: SkillState
+    get_user_tweets: SkillState
+    follow_user: SkillState
+    like_tweet: SkillState
+    retweet: SkillState
+    search_tweets: SkillState
+
+
+class Config(SkillConfig, TwitterClientConfig):
+    """Configuration for Twitter skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[TwitterBaseTool]:
+    """Get all Twitter skills."""
+    available_skills = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_twitter_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+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,
+            )
+        return _cache[name]
+    elif name == "post_tweet":
+        if name not in _cache:
+            _cache[name] = TwitterPostTweet(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "reply_tweet":
+        if name not in _cache:
+            _cache[name] = TwitterReplyTweet(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "get_timeline":
+        if name not in _cache:
+            _cache[name] = TwitterGetTimeline(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "follow_user":
+        if name not in _cache:
+            _cache[name] = TwitterFollowUser(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "like_tweet":
+        if name not in _cache:
+            _cache[name] = TwitterLikeTweet(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "retweet":
+        if name not in _cache:
+            _cache[name] = TwitterRetweet(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "search_tweets":
+        if name not in _cache:
+            _cache[name] = TwitterSearchTweets(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "get_user_by_username":
+        if name not in _cache:
+            _cache[name] = TwitterGetUserByUsername(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "get_user_tweets":
+        if name not in _cache:
+            _cache[name] = TwitterGetUserTweets(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown Twitter skill: {name}")
+        return None

intentkit/skills/twitter/base.py

@@ -0,0 +1,68 @@
+from datetime import datetime, timedelta, timezone
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.exception import RateLimitExceeded
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+
+class TwitterBaseTool(IntentKitSkill):
+    """Base class for Twitter tools."""
+
+    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"
+    )
+
+    @property
+    def category(self) -> str:
+        return "twitter"
+
+    async def check_rate_limit(
+        self, agent_id: str, 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"
+        )
+
+        current_time = datetime.now(tz=timezone.utc)
+
+        if (
+            rate_limit
+            and rate_limit.get("reset_time")
+            and rate_limit["count"] is not None
+            and datetime.fromisoformat(rate_limit["reset_time"]) > current_time
+        ):
+            if rate_limit["count"] >= max_requests:
+                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
+            )
+
+            return
+
+        # If no rate limit exists or it has expired, create a new one
+        new_rate_limit = {
+            "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
+        )
+        return

intentkit/skills/twitter/follow_user.py

@@ -0,0 +1,69 @@
+import logging
+from typing import Type
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.clients import get_twitter_client
+from intentkit.skills.twitter.base import TwitterBaseTool
+
+NAME = "twitter_follow_user"
+PROMPT = (
+    "Follow a Twitter user, if you don't know the user ID, "
+    "use twitter_get_user_by_username tool to get it."
+)
+logger = logging.getLogger(__name__)
+
+
+class TwitterFollowUserInput(BaseModel):
+    """Input for TwitterFollowUser tool."""
+
+    user_id: str = Field(description="The ID of the user to follow")
+
+
+class TwitterFollowUser(TwitterBaseTool):
+    """Tool for following a Twitter user.
+
+    This tool uses the Twitter API v2 to follow a user on Twitter.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    name: str = NAME
+    description: str = PROMPT
+    args_schema: Type[BaseModel] = TwitterFollowUserInput
+
+    async def _arun(self, user_id: str, config: RunnableConfig, **kwargs) -> bool:
+        try:
+            context = self.context_from_config(config)
+            twitter = get_twitter_client(
+                agent_id=context.agent.id,
+                skill_store=self.skill_store,
+                config=context.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
+                )
+
+            # Follow the user using tweepy client
+            response = await client.follow_user(
+                target_user_id=user_id, user_auth=twitter.use_key
+            )
+
+            if "data" in response and response["data"].get("following"):
+                return response
+            else:
+                logger.error(f"Error following user: {str(response)}")
+                raise ToolException("Failed to follow user")
+
+        except Exception as e:
+            logger.error("Error following user: %s", str(e))
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e