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

intentkit/skills/twitter/get_mentions.py

@@ -0,0 +1,124 @@
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Type
+
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import ToolException
+from pydantic import BaseModel
+
+from intentkit.clients.twitter import Tweet, get_twitter_client
+
+from .base import TwitterBaseTool
+
+NAME = "twitter_get_mentions"
+PROMPT = (
+    "Get tweets that mention you, the result is a json object containing a list of tweets."
+    'If the result is `{"meta": {"result_count": 0}}`, means no new mentions, don\'t retry this tool.'
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TwitterGetMentionsInput(BaseModel):
+    """Input for TwitterGetMentions tool."""
+
+    pass
+
+
+class TwitterGetMentions(TwitterBaseTool):
+    """Tool for getting mentions from Twitter.
+
+    This tool uses the Twitter API v2 to retrieve mentions (tweets in which the authenticated
+    user is mentioned) from 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] = TwitterGetMentionsInput
+
+    async def _arun(self, config: RunnableConfig, **kwargs) -> list[Tweet]:
+        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()
+
+            logger.debug(f"Use Key: {twitter.use_key}")
+
+            # 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=59,  # TODO: tmp to 59, back to 240 later
+                )
+
+            # get since id from store
+            last = await self.skill_store.get_agent_skill_data(
+                context.agent.id, self.name, "last"
+            )
+            last = last or {}
+            max_results = 10
+            since_id = last.get("since_id")
+            if since_id:
+                max_results = 30
+
+            # Always get mentions for the last day
+            start_time = datetime.now(tz=timezone.utc) - timedelta(days=1)
+
+            user_id = twitter.self_id
+            if not user_id:
+                raise ToolException("Failed to get Twitter user ID.")
+
+            mentions = await client.get_users_mentions(
+                user_auth=twitter.use_key,
+                id=user_id,
+                max_results=max_results,
+                since_id=since_id,
+                start_time=start_time,
+                expansions=[
+                    "referenced_tweets.id",
+                    "referenced_tweets.id.attachments.media_keys",
+                    "referenced_tweets.id.author_id",
+                    "attachments.media_keys",
+                    "author_id",
+                ],
+                tweet_fields=[
+                    "created_at",
+                    "author_id",
+                    "text",
+                    "referenced_tweets",
+                    "attachments",
+                ],
+                user_fields=[
+                    "username",
+                    "name",
+                    "profile_image_url",
+                    "description",
+                    "public_metrics",
+                    "location",
+                    "connection_status",
+                ],
+                media_fields=["url", "type", "width", "height"],
+            )
+
+            # 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
+                )
+
+            return mentions
+
+        except Exception as e:
+            logger.error(f"[agent:{context.agent.id}]: {e}")
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e

intentkit/skills/twitter/get_timeline.py

@@ -0,0 +1,111 @@
+import logging
+from typing import Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel
+
+from intentkit.clients import get_twitter_client
+
+from .base import TwitterBaseTool
+
+logger = logging.getLogger(__name__)
+
+NAME = "twitter_get_timeline"
+PROMPT = (
+    "Get tweets from your timeline, the result is a json object containing a list of tweets."
+    'If the result is `{"meta": {"result_count": 0}}`, means no new tweets, don\'t retry this tool.'
+)
+
+
+class TwitterGetTimelineInput(BaseModel):
+    """Input for TwitterGetTimeline tool."""
+
+
+class TwitterGetTimeline(TwitterBaseTool):
+    """Tool for getting the user's timeline from Twitter.
+
+    This tool uses the Twitter API v2 to retrieve tweets from the authenticated user's
+    timeline.
+
+    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] = TwitterGetTimelineInput
+
+    async def _arun(self, config: RunnableConfig, **kwargs):
+        try:
+            # Ensure max_results is an integer
+            max_results = 10
+
+            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=3, interval=60 * 24
+                )
+
+            # get since id from store
+            last = await self.skill_store.get_agent_skill_data(
+                context.agent.id, self.name, "last"
+            )
+            last = last or {}
+            since_id = last.get("since_id")
+
+            user_id = twitter.self_id
+            if not user_id:
+                raise ValueError("Failed to get Twitter user ID.")
+
+            timeline = await client.get_home_timeline(
+                user_auth=twitter.use_key,
+                max_results=max_results,
+                since_id=since_id,
+                expansions=[
+                    "referenced_tweets.id",
+                    "referenced_tweets.id.attachments.media_keys",
+                    "referenced_tweets.id.author_id",
+                    "attachments.media_keys",
+                    "author_id",
+                ],
+                tweet_fields=[
+                    "created_at",
+                    "author_id",
+                    "text",
+                    "referenced_tweets",
+                    "attachments",
+                ],
+                user_fields=[
+                    "username",
+                    "name",
+                    "profile_image_url",
+                    "description",
+                    "public_metrics",
+                    "location",
+                    "connection_status",
+                ],
+                media_fields=["url", "type", "width", "height"],
+            )
+
+            # 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
+                )
+
+            return timeline
+
+        except Exception as e:
+            logger.error("Error getting timeline: %s", str(e))
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e

intentkit/skills/twitter/get_user_by_username.py

@@ -0,0 +1,84 @@
+import logging
+from typing import Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.clients import get_twitter_client
+
+from .base import TwitterBaseTool
+
+logger = logging.getLogger(__name__)
+
+NAME = "twitter_get_user_by_username"
+PROMPT = (
+    "Get a Twitter user's information by their username."
+    "Returns detailed user information as a json object."
+)
+
+
+class TwitterGetUserByUsernameInput(BaseModel):
+    """Input for TwitterGetUserByUsername tool."""
+
+    username: str = Field(description="The Twitter username to lookup")
+
+
+class TwitterGetUserByUsername(TwitterBaseTool):
+    """Tool for getting a Twitter user by their username.
+
+    This tool uses the Twitter API v2 to retrieve user information by username.
+
+    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] = TwitterGetUserByUsernameInput
+
+    async def _arun(self, username: str, config: RunnableConfig, **kwargs):
+        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=3, interval=60 * 24
+                )
+
+            user_data = await client.get_user(
+                username=username,
+                user_auth=twitter.use_key,
+                user_fields=[
+                    "created_at",
+                    "description",
+                    "entities",
+                    "connection_status",
+                    "id",
+                    "location",
+                    "name",
+                    "pinned_tweet_id",
+                    "profile_image_url",
+                    "protected",
+                    "public_metrics",
+                    "url",
+                    "username",
+                    "verified",
+                    "verified_type",
+                    "withheld",
+                ],
+            )
+
+            return user_data
+
+        except Exception as e:
+            logger.error(f"Error getting user by username: {str(e)}")
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e

intentkit/skills/twitter/get_user_tweets.py

@@ -0,0 +1,123 @@
+import logging
+from typing import List, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.clients import get_twitter_client
+
+from .base import TwitterBaseTool
+
+logger = logging.getLogger(__name__)
+
+NAME = "twitter_get_user_tweets"
+PROMPT = (
+    "Get tweets from a specific Twitter user by their user ID. "
+    "The result is a json object containing a list of tweets."
+    'If the result is `{"meta": {"result_count": 0}}`, means no tweets found, don\'t retry this tool.'
+)
+
+
+class TwitterGetUserTweetsInput(BaseModel):
+    """Input for TwitterGetUserTweets tool."""
+
+    user_id: str = Field(description="The Twitter user ID to fetch tweets from")
+    exclude: Optional[List[str]] = Field(
+        default=["replies", "retweets"],
+        description="Types of tweets to exclude (e.g., 'replies', 'retweets')",
+    )
+
+
+class TwitterGetUserTweets(TwitterBaseTool):
+    """Tool for getting tweets from a specific Twitter user.
+
+    This tool uses the Twitter API v2 to retrieve tweets from a specific user
+    by their user ID.
+
+    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] = TwitterGetUserTweetsInput
+
+    async def _arun(self, config: RunnableConfig, **kwargs):
+        try:
+            user_id = kwargs.get("user_id")
+            if not user_id:
+                raise ValueError("User ID is required")
+
+            # Hardcode max_results to 10
+            max_results = 10
+
+            # Get exclude parameter with default
+            exclude = kwargs.get("exclude", ["replies", "retweets"])
+
+            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=3, interval=60 * 24
+                )
+
+            # get since id from store
+            last = await self.skill_store.get_agent_skill_data(
+                context.agent.id, self.name, user_id
+            )
+            last = last or {}
+            since_id = last.get("since_id")
+
+            tweets = await client.get_users_tweets(
+                user_auth=twitter.use_key,
+                id=user_id,
+                max_results=max_results,
+                since_id=since_id,
+                exclude=exclude,
+                expansions=[
+                    "referenced_tweets.id",
+                    "referenced_tweets.id.attachments.media_keys",
+                    "referenced_tweets.id.author_id",
+                    "attachments.media_keys",
+                    "author_id",
+                ],
+                tweet_fields=[
+                    "created_at",
+                    "author_id",
+                    "text",
+                    "referenced_tweets",
+                    "attachments",
+                ],
+                user_fields=[
+                    "username",
+                    "name",
+                    "profile_image_url",
+                    "description",
+                    "public_metrics",
+                    "location",
+                    "connection_status",
+                ],
+                media_fields=["url", "type", "width", "height"],
+            )
+
+            # 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
+                )
+
+            return tweets
+
+        except Exception as e:
+            logger.error("Error getting user tweets: %s", str(e))
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e

intentkit/skills/twitter/like_tweet.py

@@ -0,0 +1,65 @@
+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_like_tweet"
+PROMPT = "Like a tweet on Twitter"
+
+logger = logging.getLogger(__name__)
+
+
+class TwitterLikeTweetInput(BaseModel):
+    """Input for TwitterLikeTweet tool."""
+
+    tweet_id: str = Field(description="The ID of the tweet to like")
+
+
+class TwitterLikeTweet(TwitterBaseTool):
+    """Tool for liking tweets on Twitter.
+
+    This tool uses the Twitter API v2 to like tweets 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] = TwitterLikeTweetInput
+
+    async def _arun(self, tweet_id: str, config: RunnableConfig, **kwargs):
+        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=100, interval=1440
+                )
+
+            # Like the tweet using tweepy client
+            response = await client.like(tweet_id=tweet_id, user_auth=twitter.use_key)
+
+            if "data" in response and "liked" in response["data"]:
+                return response
+            else:
+                logger.error(f"Error liking tweet: {str(response)}")
+                raise ToolException("Failed to like tweet.")
+
+        except Exception as e:
+            logger.error(f"Error liking tweet: {str(e)}")
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e

intentkit/skills/twitter/post_tweet.py

@@ -0,0 +1,90 @@
+import logging
+from typing import Optional, 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_post_tweet"
+PROMPT = (
+    "Post a new tweet to Twitter. If you want to post image, "
+    "you must provide image url in parameters, do not add image link in text."
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TwitterPostTweetInput(BaseModel):
+    """Input for TwitterPostTweet tool."""
+
+    text: str = Field(
+        description="Tweet text (280 chars for regular users, 25,000 bytes for verified)",
+        max_length=25000,
+    )
+    image: Optional[str] = Field(
+        default=None, description="Optional URL of an image to attach to the tweet"
+    )
+
+
+class TwitterPostTweet(TwitterBaseTool):
+    """Tool for posting tweets to Twitter.
+
+    This tool uses the Twitter API v2 to post new tweets to 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] = TwitterPostTweetInput
+
+    async def _arun(
+        self,
+        text: str,
+        image: Optional[str] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ):
+        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=24, interval=1440
+                )
+
+            media_ids = []
+
+            # Handle image upload if provided
+            if image:
+                # Use the TwitterClient method to upload the image
+                media_ids = await twitter.upload_media(context.agent.id, image)
+
+            # Post tweet using tweepy client
+            tweet_params = {"text": text, "user_auth": twitter.use_key}
+            if media_ids:
+                tweet_params["media_ids"] = media_ids
+
+            response = await client.create_tweet(**tweet_params)
+            if "data" in response and "id" in response["data"]:
+                return response
+            else:
+                logger.error(f"Error posting tweet: {str(response)}")
+                raise ToolException("Failed to post tweet.")
+
+        except Exception as e:
+            logger.error(f"Error posting tweet: {str(e)}")
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e

intentkit/skills/twitter/reply_tweet.py

@@ -0,0 +1,98 @@
+import logging
+from typing import Optional, 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_reply_tweet"
+PROMPT = (
+    "Reply to an existing tweet on Twitter. If you want to post image, "
+    "you must provide image url in parameters, do not add image link in text."
+)
+
+logger = logging.getLogger(__name__)
+
+
+class TwitterReplyTweetInput(BaseModel):
+    """Input for TwitterReplyTweet tool."""
+
+    tweet_id: str = Field(description="The ID of the tweet to reply to")
+    text: str = Field(
+        description="Tweet text (280 chars for regular users, 25,000 bytes for verified)",
+        max_length=25000,
+    )
+    image: Optional[str] = Field(
+        default=None, description="Optional URL of an image to attach to the reply"
+    )
+
+
+class TwitterReplyTweet(TwitterBaseTool):
+    """Tool for replying to tweets on Twitter.
+
+    This tool uses the Twitter API v2 to post reply tweets to existing tweets.
+
+    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] = TwitterReplyTweetInput
+
+    async def _arun(
+        self,
+        tweet_id: str,
+        text: str,
+        image: Optional[str] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ):
+        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=48, interval=1440
+                )
+
+            media_ids = []
+
+            # Handle image upload if provided
+            if image:
+                # Use the TwitterClient method to upload the image
+                media_ids = await twitter.upload_media(context.agent.id, image)
+
+            # Post reply tweet using tweepy client
+            tweet_params = {
+                "text": text,
+                "user_auth": twitter.use_key,
+                "in_reply_to_tweet_id": tweet_id,
+            }
+
+            if media_ids:
+                tweet_params["media_ids"] = media_ids
+
+            response = await client.create_tweet(**tweet_params)
+
+            if "data" in response and "id" in response["data"]:
+                return response
+            else:
+                logger.error(f"Error replying to tweet: {str(response)}")
+                raise ToolException("Failed to post reply tweet.")
+
+        except Exception as e:
+            logger.error(f"Error replying to tweet: {str(e)}")
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e