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

intentkit/skills/cookiefun/__init__.py

@@ -0,0 +1,78 @@
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.cookiefun.base import CookieFunBaseTool, logger
+from intentkit.skills.cookiefun.get_account_details import GetAccountDetails
+from intentkit.skills.cookiefun.get_account_feed import GetAccountFeed
+from intentkit.skills.cookiefun.get_account_smart_followers import (
+    GetAccountSmartFollowers,
+)
+from intentkit.skills.cookiefun.get_sectors import GetSectors
+from intentkit.skills.cookiefun.search_accounts import SearchAccounts
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, CookieFunBaseTool] = {}
+
+
+class SkillStates(TypedDict):
+    """States for CookieFun skills."""
+
+    get_sectors: SkillState
+    get_account_details: SkillState
+    get_account_smart_followers: SkillState
+    search_accounts: SkillState
+    get_account_feed: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for CookieFun skills."""
+
+    states: SkillStates
+    api_key: str
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[CookieFunBaseTool]:
+    """Get all CookieFun 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
+    skills = [get_cookiefun_skill(name, store) for name in available_skills]
+    logger.info("Returning %d CookieFun skills", len(skills))
+    return skills
+
+
+def get_cookiefun_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> CookieFunBaseTool:
+    """Get a CookieFun skill by name."""
+
+    if name not in _cache:
+        if name == "get_sectors":
+            _cache[name] = GetSectors(skill_store=store)
+        elif name == "get_account_details":
+            _cache[name] = GetAccountDetails(skill_store=store)
+        elif name == "get_account_smart_followers":
+            _cache[name] = GetAccountSmartFollowers(skill_store=store)
+        elif name == "search_accounts":
+            _cache[name] = SearchAccounts(skill_store=store)
+        elif name == "get_account_feed":
+            _cache[name] = GetAccountFeed(skill_store=store)
+        else:
+            logger.error("Unknown CookieFun skill: %s", name)
+            raise ValueError(f"Unknown CookieFun skill: {name}")
+
+    return _cache[name]

intentkit/skills/cookiefun/base.py

@@ -0,0 +1,41 @@
+import logging
+from typing import Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+logger = logging.getLogger(__name__)
+
+
+class CookieFunBaseTool(IntentKitSkill):
+    """Base class for CookieFun 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 "cookiefun"
+
+    def get_api_key(self, config: RunnableConfig) -> Optional[str]:
+        """
+        Get the API key from configuration.
+
+        Args:
+            config: The runnable configuration containing context
+
+        Returns:
+            The API key or None if not configured
+        """
+        context = self.context_from_config(config)
+        skill_config = context.config
+        if skill_config.get("api_key_provider") == "agent_owner":
+            return skill_config.get("api_key")
+        return self.skill_store.get_system_config("cookiefun_api_key")

intentkit/skills/cookiefun/constants.py

@@ -0,0 +1,18 @@
+"""
+Constants for the CookieFun skills.
+"""
+
+# API Base URL
+BASE_URL = "https://api.staging.cookie.fun/v3"
+
+# API Endpoints
+ENDPOINTS = {
+    "sectors": f"{BASE_URL}/sectors",
+    "account_details": f"{BASE_URL}/account/",
+    "smart_followers": f"{BASE_URL}/account/smart-followers",
+    "search_accounts": f"{BASE_URL}/account/query",
+    "account_feed": f"{BASE_URL}/account/feed",
+}
+
+# Default Headers
+DEFAULT_HEADERS = {"Content-Type": "application/json"}

intentkit/skills/cookiefun/get_account_details.py

@@ -0,0 +1,171 @@
+from typing import Any, Dict, Optional, Type, Union
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.cookiefun.base import CookieFunBaseTool, logger
+from intentkit.skills.cookiefun.constants import DEFAULT_HEADERS, ENDPOINTS
+
+
+class GetAccountDetailsInput(BaseModel):
+    """Input for GetAccountDetails tool."""
+
+    username: Optional[str] = Field(
+        default=None,
+        description="Twitter username (either username or userId is required)",
+    )
+
+    userId: Optional[str] = Field(
+        default=None,
+        description="Twitter user ID (either username or userId is required)",
+    )
+
+
+class GetAccountDetails(CookieFunBaseTool):
+    """Tool to get detailed information about a Twitter account."""
+
+    name: str = "cookiefun_get_account_details"
+    description: str = "Retrieves detailed information about a Twitter account including followers, following, posts, metrics, and engagement data."
+    args_schema: Type[BaseModel] = GetAccountDetailsInput
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        username: Optional[str] = None,
+        userId: Optional[str] = None,
+        **kwargs,
+    ) -> Union[Dict[str, Any], str]:
+        """
+        Get detailed information about a Twitter account.
+
+        Args:
+            username: Twitter username (either username or userId is required)
+            userId: Twitter user ID (either username or userId is required)
+
+        Returns:
+            Account details including followers, following, posts, metrics, and engagement data.
+        """
+        logger.info(
+            "Getting account details for username=%s, userId=%s", username, userId
+        )
+
+        # Validate input parameters
+        if not username and not userId:
+            logger.error("Neither username nor userId provided")
+            return "Error: Either username or userId must be provided."
+
+        try:
+            # Get context to retrieve API key
+            api_key = self.get_api_key(config)
+
+            if not api_key:
+                logger.error("No API key provided for CookieFun API")
+                return "Error: No API key provided for CookieFun API. Please configure the API key in the agent settings."
+
+            # Prepare request payload
+            payload = {}
+            if username:
+                payload["username"] = username
+            if userId:
+                payload["userId"] = userId
+
+            # Make API request
+            headers = {**DEFAULT_HEADERS, "x-api-key": api_key}
+
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    ENDPOINTS["account_details"], headers=headers, json=payload
+                )
+                logger.debug(
+                    "Received response with status code: %d", response.status_code
+                )
+
+                response.raise_for_status()
+                data = response.json()
+
+                # Check different possible response structures
+                if (
+                    data.get("success")
+                    and "ok" in data
+                    and isinstance(data["ok"], dict)
+                ):
+                    logger.info("Successfully retrieved account details")
+                    return data["ok"]
+                elif data.get("success") and "ok" in data and "entry" in data["ok"]:
+                    logger.info(
+                        "Successfully retrieved account details from entry field"
+                    )
+                    return data["ok"]["entry"]
+                elif (
+                    data.get("success")
+                    and "ok" in data
+                    and "entries" in data["ok"]
+                    and len(data["ok"]["entries"]) > 0
+                ):
+                    # If entries is a list but we expect a single account, return the first one
+                    logger.info(
+                        "Successfully retrieved account details from entries array"
+                    )
+                    return data["ok"]["entries"][0]
+                elif data.get("success") and isinstance(data.get("account"), dict):
+                    # If account is at the top level
+                    logger.info("Successfully retrieved account details from top level")
+                    return data["account"]
+                elif data.get("success") and isinstance(data.get("entry"), dict):
+                    # If entry is at the top level
+                    logger.info(
+                        "Successfully retrieved account details from entry field"
+                    )
+                    return data["entry"]
+                elif (
+                    data.get("success")
+                    and isinstance(data.get("entries"), list)
+                    and len(data.get("entries")) > 0
+                ):
+                    # If entries is at the top level
+                    logger.info(
+                        "Successfully retrieved account details from entries array at top level"
+                    )
+                    return data["entries"][0]
+                elif "account" in data and isinstance(data["account"], dict):
+                    # If only account field exists
+                    logger.info("Successfully retrieved account from direct field")
+                    return data["account"]
+                elif "entry" in data and isinstance(data["entry"], dict):
+                    # If only entry field exists
+                    logger.info(
+                        "Successfully retrieved account from direct entry field"
+                    )
+                    return data["entry"]
+                elif (
+                    "entries" in data
+                    and isinstance(data["entries"], list)
+                    and len(data["entries"]) > 0
+                ):
+                    # If only entries field exists
+                    logger.info(
+                        "Successfully retrieved account from direct entries field"
+                    )
+                    return data["entries"][0]
+                else:
+                    # If we can't find account details in the expected structure, log the full response
+                    logger.error(
+                        "Could not find account details in response structure. Full response: %s",
+                        data,
+                    )
+                    error_msg = data.get(
+                        "error", "Unknown error - check API response format"
+                    )
+                    logger.error("Error in API response: %s", error_msg)
+                    return f"Error fetching account details: {error_msg}"
+
+        except httpx.HTTPStatusError as e:
+            logger.error("HTTP error: %d - %s", e.response.status_code, e.response.text)
+            return f"HTTP error occurred: {e.response.status_code} - {e.response.text}"
+        except httpx.RequestError as e:
+            logger.error("Request error: %s", str(e))
+            return f"Request error occurred: {str(e)}"
+        except Exception as e:
+            logger.exception("Unexpected error occurred")
+            return f"An unexpected error occurred: {str(e)}"

intentkit/skills/cookiefun/get_account_feed.py

@@ -0,0 +1,282 @@
+from enum import IntEnum
+from typing import Any, Dict, List, Optional, Type, Union
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.cookiefun.base import CookieFunBaseTool, logger
+from intentkit.skills.cookiefun.constants import DEFAULT_HEADERS, ENDPOINTS
+
+
+class TweetType(IntEnum):
+    """Tweet type for filtering."""
+
+    Original = 0
+    Reply = 1
+    Quote = 2
+
+
+class SortBy(IntEnum):
+    """Sort options for tweets."""
+
+    CreatedDate = 0
+    Impressions = 1
+
+
+class SortOrder(IntEnum):
+    """Sort order options."""
+
+    Ascending = 0
+    Descending = 1
+
+
+class GetAccountFeedInput(BaseModel):
+    """Input for GetAccountFeed tool."""
+
+    username: Optional[str] = Field(
+        default=None,
+        description="Twitter username (either username or userId is required)",
+    )
+
+    userId: Optional[str] = Field(
+        default=None,
+        description="Twitter user ID (either username or userId is required)",
+    )
+
+    startDate: Optional[str] = Field(
+        default=None,
+        description="Start date for filtering in format dd/mm/yyyy (default: 30 days ago)",
+    )
+
+    endDate: Optional[str] = Field(
+        default=None,
+        description="End date for filtering in format dd/mm/yyyy (default: now)",
+    )
+
+    type: Optional[int] = Field(
+        default=None,
+        description="Type of tweets to filter: 0 for Original, 1 for Reply, 2 for Quote (leave empty for all types)",
+    )
+
+    hasMedia: Optional[bool] = Field(
+        default=None,
+        description="Filter to only include tweets with media if true",
+    )
+
+    sortBy: Optional[int] = Field(
+        default=None,
+        description="Sort by: 0 for CreatedDate, 1 for Impressions",
+    )
+
+    sortOrder: Optional[int] = Field(
+        default=None,
+        description="Sort order: 0 for Ascending, 1 for Descending",
+    )
+
+
+class GetAccountFeed(CookieFunBaseTool):
+    """Tool to get the feed (tweets) of a Twitter account."""
+
+    name: str = "cookiefun_get_account_feed"
+    description: str = "Retrieves a list of tweets for a specific Twitter account with various filtering options."
+    args_schema: Type[BaseModel] = GetAccountFeedInput
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        username: Optional[str] = None,
+        userId: Optional[str] = None,
+        startDate: Optional[str] = None,
+        endDate: Optional[str] = None,
+        type: Optional[int] = None,
+        hasMedia: Optional[bool] = None,
+        sortBy: Optional[int] = None,
+        sortOrder: Optional[int] = None,
+        **kwargs,
+    ) -> Union[List[Dict[str, Any]], str]:
+        """
+        Get the feed (tweets) of a Twitter account.
+
+        Args:
+            username: Twitter username (either username or userId is required)
+            userId: Twitter user ID (either username or userId is required)
+            startDate: Start date for filtering in format dd/mm/yyyy (default: 30 days ago)
+            endDate: End date for filtering in format dd/mm/yyyy (default: now)
+            type: Type of tweets to filter (0=Original, 1=Reply, 2=Quote)
+            hasMedia: Filter to only include tweets with media if true
+            sortBy: Sort by field (0=CreatedDate, 1=Impressions)
+            sortOrder: Sort order (0=Ascending, 1=Descending)
+
+        Returns:
+            List of tweets from the specified account matching the filter criteria.
+        """
+        logger.info(
+            "Getting account feed for username=%s, userId=%s, startDate=%s, endDate=%s, type=%s, hasMedia=%s, sortBy=%s, sortOrder=%s",
+            username,
+            userId,
+            startDate,
+            endDate,
+            type,
+            hasMedia,
+            sortBy,
+            sortOrder,
+        )
+
+        # Validate input parameters
+        if not username and not userId:
+            logger.error("Neither username nor userId provided")
+            return "Error: Either username or userId must be provided."
+
+        try:
+            # Get context to retrieve API key
+            api_key = self.get_api_key(config)
+
+            if not api_key:
+                logger.error("No API key provided for CookieFun API")
+                return "Error: No API key provided for CookieFun API. Please configure the API key in the agent settings."
+
+            # Prepare request payload
+            payload = {}
+            if username:
+                payload["username"] = username
+            if userId:
+                payload["userId"] = userId
+            if startDate:
+                payload["startDate"] = startDate
+            if endDate:
+                payload["endDate"] = endDate
+            if type is not None:
+                payload["type"] = type
+            if hasMedia is not None:
+                payload["hasMedia"] = hasMedia
+            if sortBy is not None:
+                payload["sortBy"] = sortBy
+            if sortOrder is not None:
+                payload["sortOrder"] = sortOrder
+
+            # Make API request
+            headers = {**DEFAULT_HEADERS, "x-api-key": api_key}
+
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    ENDPOINTS["account_feed"], headers=headers, json=payload
+                )
+                logger.debug(
+                    "Received response with status code: %d", response.status_code
+                )
+
+                response.raise_for_status()
+                data = response.json()
+
+                # Check different possible response structures
+                if data.get("success") and "ok" in data and "entries" in data["ok"]:
+                    tweets = data["ok"]["entries"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from entries field",
+                        len(tweets),
+                    )
+                    return tweets
+                elif data.get("success") and "ok" in data and "tweets" in data["ok"]:
+                    tweets = data["ok"]["tweets"]
+                    logger.info("Successfully retrieved %d tweets", len(tweets))
+                    return tweets
+                elif data.get("success") and "ok" in data and "posts" in data["ok"]:
+                    tweets = data["ok"]["posts"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from posts field", len(tweets)
+                    )
+                    return tweets
+                elif data.get("success") and "ok" in data and "feed" in data["ok"]:
+                    tweets = data["ok"]["feed"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from feed field", len(tweets)
+                    )
+                    return tweets
+                elif (
+                    data.get("success")
+                    and "ok" in data
+                    and isinstance(data["ok"], list)
+                ):
+                    tweets = data["ok"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from ok list", len(tweets)
+                    )
+                    return tweets
+                elif data.get("success") and isinstance(data.get("tweets"), list):
+                    tweets = data["tweets"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from top level tweets",
+                        len(tweets),
+                    )
+                    return tweets
+                elif data.get("success") and isinstance(data.get("posts"), list):
+                    tweets = data["posts"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from top level posts",
+                        len(tweets),
+                    )
+                    return tweets
+                elif data.get("success") and isinstance(data.get("feed"), list):
+                    tweets = data["feed"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from top level feed",
+                        len(tweets),
+                    )
+                    return tweets
+                elif data.get("success") and isinstance(data.get("entries"), list):
+                    tweets = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from top level entries",
+                        len(tweets),
+                    )
+                    return tweets
+                elif "tweets" in data and isinstance(data["tweets"], list):
+                    tweets = data["tweets"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from direct tweets field",
+                        len(tweets),
+                    )
+                    return tweets
+                elif "posts" in data and isinstance(data["posts"], list):
+                    tweets = data["posts"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from direct posts field",
+                        len(tweets),
+                    )
+                    return tweets
+                elif "feed" in data and isinstance(data["feed"], list):
+                    tweets = data["feed"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from direct feed field",
+                        len(tweets),
+                    )
+                    return tweets
+                elif "entries" in data and isinstance(data["entries"], list):
+                    tweets = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d tweets from direct entries field",
+                        len(tweets),
+                    )
+                    return tweets
+                else:
+                    # If we can't find tweets in the expected structure, log the full response
+                    logger.error(
+                        "Could not find tweets in response structure. Full response: %s",
+                        data,
+                    )
+                    error_msg = data.get(
+                        "error", "Unknown error - check API response format"
+                    )
+                    logger.error("Error in API response: %s", error_msg)
+                    return f"Error fetching account feed: {error_msg}"
+
+        except httpx.HTTPStatusError as e:
+            logger.error("HTTP error: %d - %s", e.response.status_code, e.response.text)
+            return f"HTTP error occurred: {e.response.status_code} - {e.response.text}"
+        except httpx.RequestError as e:
+            logger.error("Request error: %s", str(e))
+            return f"Request error occurred: {str(e)}"
+        except Exception as e:
+            logger.exception("Unexpected error occurred")
+            return f"An unexpected error occurred: {str(e)}"