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

intentkit/skills/cookiefun/get_account_smart_followers.py

@@ -0,0 +1,181 @@
+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 GetAccountSmartFollowersInput(BaseModel):
+    """Input for GetAccountSmartFollowers 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 GetAccountSmartFollowers(CookieFunBaseTool):
+    """Tool to get smart followers for a Twitter account."""
+
+    name: str = "cookiefun_get_account_smart_followers"
+    description: str = "Returns a list of top smart followers for a specific Twitter account, with detailed metrics about these followers."
+    args_schema: Type[BaseModel] = GetAccountSmartFollowersInput
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        username: Optional[str] = None,
+        userId: Optional[str] = None,
+        **kwargs,
+    ) -> Union[List[Dict[str, Any]], str]:
+        """
+        Get smart followers for a Twitter account.
+
+        Args:
+            username: Twitter username (either username or userId is required)
+            userId: Twitter user ID (either username or userId is required)
+
+        Returns:
+            List of top smart followers with their metrics.
+        """
+        logger.info(
+            "Getting smart followers 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["smart_followers"], 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"]:
+                    followers = data["ok"]["entries"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from entries field",
+                        len(followers),
+                    )
+                    return followers
+                elif data.get("success") and "ok" in data and "accounts" in data["ok"]:
+                    followers = data["ok"]["accounts"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers", len(followers)
+                    )
+                    return followers
+                elif data.get("success") and "ok" in data and "followers" in data["ok"]:
+                    followers = data["ok"]["followers"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from followers field",
+                        len(followers),
+                    )
+                    return followers
+                elif (
+                    data.get("success")
+                    and "ok" in data
+                    and isinstance(data["ok"], list)
+                ):
+                    followers = data["ok"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from ok list",
+                        len(followers),
+                    )
+                    return followers
+                elif data.get("success") and isinstance(data.get("accounts"), list):
+                    followers = data["accounts"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from top level accounts",
+                        len(followers),
+                    )
+                    return followers
+                elif data.get("success") and isinstance(data.get("followers"), list):
+                    followers = data["followers"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from top level followers",
+                        len(followers),
+                    )
+                    return followers
+                elif data.get("success") and isinstance(data.get("entries"), list):
+                    followers = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from top level entries",
+                        len(followers),
+                    )
+                    return followers
+                elif "followers" in data and isinstance(data["followers"], list):
+                    followers = data["followers"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from direct followers field",
+                        len(followers),
+                    )
+                    return followers
+                elif "accounts" in data and isinstance(data["accounts"], list):
+                    followers = data["accounts"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from direct accounts field",
+                        len(followers),
+                    )
+                    return followers
+                elif "entries" in data and isinstance(data["entries"], list):
+                    followers = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d smart followers from direct entries field",
+                        len(followers),
+                    )
+                    return followers
+                else:
+                    # If we can't find followers in the expected structure, log the full response
+                    logger.error(
+                        "Could not find smart followers 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 smart followers: {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_sectors.py

@@ -0,0 +1,128 @@
+from typing import Any, Dict, List, Type
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel
+
+from intentkit.skills.cookiefun.base import CookieFunBaseTool, logger
+from intentkit.skills.cookiefun.constants import DEFAULT_HEADERS, ENDPOINTS
+
+
+class GetSectorsInput(BaseModel):
+    """Input for GetSectors tool."""
+
+    pass
+
+
+class GetSectors(CookieFunBaseTool):
+    """Tool to get all available sectors from the CookieFun API."""
+
+    name: str = "cookiefun_get_sectors"
+    description: str = (
+        "Returns a list of all available sectors in the CookieFun system."
+    )
+    args_schema: Type[BaseModel] = GetSectorsInput
+
+    async def _arun(self, config: RunnableConfig, **kwargs) -> List[Dict[str, Any]]:
+        """
+        Get all available sectors from the CookieFun API.
+
+        Returns:
+            List of sector objects, each containing id, name, and other metadata.
+        """
+        logger.info("Getting sectors from CookieFun API")
+        try:
+            # Get 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."
+
+            # Make API request
+            headers = {**DEFAULT_HEADERS, "x-api-key": api_key}
+
+            async with httpx.AsyncClient() as client:
+                response = await client.get(ENDPOINTS["sectors"], headers=headers)
+                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"]:
+                    sectors = data["ok"]["entries"]
+                    logger.info(
+                        "Successfully retrieved %d sectors from entries field",
+                        len(sectors),
+                    )
+                    return sectors
+                elif data.get("success") and "ok" in data and "sectors" in data["ok"]:
+                    sectors = data["ok"]["sectors"]
+                    logger.info("Successfully retrieved %d sectors", len(sectors))
+                    return sectors
+                elif (
+                    data.get("success")
+                    and "ok" in data
+                    and isinstance(data["ok"], list)
+                ):
+                    # If "ok" is directly a list
+                    sectors = data["ok"]
+                    logger.info(
+                        "Successfully retrieved %d sectors from ok list", len(sectors)
+                    )
+                    return sectors
+                elif data.get("success") and isinstance(data.get("sectors"), list):
+                    # If sectors is at the top level
+                    sectors = data["sectors"]
+                    logger.info(
+                        "Successfully retrieved %d sectors from top level", len(sectors)
+                    )
+                    return sectors
+                elif data.get("success") and isinstance(data.get("entries"), list):
+                    # If entries is at the top level
+                    sectors = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d sectors from entries top level",
+                        len(sectors),
+                    )
+                    return sectors
+                elif "sectors" in data and isinstance(data["sectors"], list):
+                    # If only sectors field exists
+                    sectors = data["sectors"]
+                    logger.info(
+                        "Successfully retrieved %d sectors from direct field",
+                        len(sectors),
+                    )
+                    return sectors
+                elif "entries" in data and isinstance(data["entries"], list):
+                    # If only entries field exists
+                    sectors = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d sectors from direct entries field",
+                        len(sectors),
+                    )
+                    return sectors
+                else:
+                    # If we can't find sectors in the expected structure, log the full response for debugging
+                    logger.error(
+                        "Could not find sectors 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 sectors: {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/schema.json

@@ -0,0 +1,155 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "CookieFun Skills",
+  "description": "Access Twitter/X analytics and insights using CookieFun API. Get data about accounts, tweets, followers, and trends across different industry sectors.",
+  "x-icon": "https://ai.service.crestal.dev/skills/cookiefun/cookiefun.png",
+  "x-tags": [
+    "Twitter",
+    "Social Media",
+    "Analytics",
+    "X"
+  ],
+  "x-nft-requirement": 10,
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Toggle to enable or disable all CookieFun skills",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "get_sectors": {
+          "type": "string",
+          "title": "Get Sectors",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Retrieve a list of all available industry sectors in CookieFun, useful for exploring trending topics and categorization",
+          "default": "disabled"
+        },
+        "get_account_details": {
+          "type": "string",
+          "title": "Get Account Details",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Fetch comprehensive metrics about any Twitter account including followers, engagement rates, impressions, and other analytics",
+          "default": "disabled"
+        },
+        "get_account_smart_followers": {
+          "type": "string",
+          "title": "Get Account Smart Followers",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Identify the most valuable followers of any Twitter account based on influence, engagement, and reach metrics",
+          "default": "disabled"
+        },
+        "search_accounts": {
+          "type": "string",
+          "title": "Search Accounts",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Find Twitter accounts posting about specific topics with filtering by engagement, impressions, and tweet types",
+          "default": "disabled"
+        },
+        "get_account_feed": {
+          "type": "string",
+          "title": "Get Account Feed",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Access a Twitter account's feed with powerful filtering by date range, media content, tweet type, and sorting options",
+          "default": "disabled"
+        }
+      },
+      "description": "Configure access levels for each CookieFun skill - disabled, available to all users, or restricted to agent owner only"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Choose whether to use a platform-provided API key or provide your own CookieFun API key",
+      "enum": [
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Owner Provided"
+      ],
+      "default": "agent_owner"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "api_key": {
+        "type": "string",
+        "title": "CookieFun API Key",
+        "description": "Your personal CookieFun API key, required when using Owner Provided option (sign up at cookie.fun)",
+        "x-sensitive": true,
+        "x-link": "[Get your API key](https://cookie.fun/)"
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "api_key"
+      ]
+    }
+  },
+  "additionalProperties": true
+}

intentkit/skills/cookiefun/search_accounts.py

@@ -0,0 +1,225 @@
+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 account search results."""
+
+    SmartEngagementPoints = 0
+    Impressions = 1
+    MatchingTweetsCount = 2
+
+
+class SortOrder(IntEnum):
+    """Sort order options."""
+
+    Ascending = 0
+    Descending = 1
+
+
+class SearchAccountsInput(BaseModel):
+    """Input for SearchAccounts tool."""
+
+    searchQuery: str = Field(
+        description="Search query to find Twitter accounts that authored tweets matching the criteria"
+    )
+
+    type: Optional[int] = Field(
+        default=None,
+        description="Type of tweets to search for: 0 for Original, 1 for Reply, 2 for Quote (leave empty for all types)",
+    )
+
+    sortBy: Optional[int] = Field(
+        default=None,
+        description="Sort by: 0 for SmartEngagementPoints, 1 for Impressions, 2 for MatchingTweetsCount",
+    )
+
+    sortOrder: Optional[int] = Field(
+        default=None,
+        description="Sort order: 0 for Ascending, 1 for Descending",
+    )
+
+
+class SearchAccounts(CookieFunBaseTool):
+    """Tool to search for Twitter accounts based on tweet content."""
+
+    name: str = "cookiefun_search_accounts"
+    description: str = "Searches for Twitter accounts that authored tweets matching specified search criteria."
+    args_schema: Type[BaseModel] = SearchAccountsInput
+
+    async def _arun(
+        self,
+        config: RunnableConfig,
+        searchQuery: str,
+        type: Optional[int] = None,
+        sortBy: Optional[int] = None,
+        sortOrder: Optional[int] = None,
+        **kwargs,
+    ) -> Union[List[Dict[str, Any]], str]:
+        """
+        Search for Twitter accounts based on tweet content.
+
+        Args:
+            searchQuery: Search query to match tweet content
+            type: Type of tweets to search for (0=Original, 1=Reply, 2=Quote)
+            sortBy: Sort by field (0=SmartEngagementPoints, 1=Impressions, 2=MatchingTweetsCount)
+            sortOrder: Sort order (0=Ascending, 1=Descending)
+
+        Returns:
+            List of Twitter accounts matching the search criteria with metrics.
+        """
+        logger.info(
+            "Searching accounts with query=%s, type=%s, sortBy=%s, sortOrder=%s",
+            searchQuery,
+            type,
+            sortBy,
+            sortOrder,
+        )
+
+        if not searchQuery:
+            logger.error("No search query provided")
+            return "Error: searchQuery is required."
+
+        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 = {"searchQuery": searchQuery}
+
+            # Add optional parameters if provided
+            if type is not None:
+                payload["type"] = type
+            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["search_accounts"], 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"]:
+                    accounts = data["ok"]["entries"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from entries field",
+                        len(accounts),
+                    )
+                    return accounts
+                elif data.get("success") and "ok" in data and "accounts" in data["ok"]:
+                    accounts = data["ok"]["accounts"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts", len(accounts)
+                    )
+                    return accounts
+                elif data.get("success") and "ok" in data and "results" in data["ok"]:
+                    accounts = data["ok"]["results"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from results field",
+                        len(accounts),
+                    )
+                    return accounts
+                elif (
+                    data.get("success")
+                    and "ok" in data
+                    and isinstance(data["ok"], list)
+                ):
+                    accounts = data["ok"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from ok list",
+                        len(accounts),
+                    )
+                    return accounts
+                elif data.get("success") and isinstance(data.get("accounts"), list):
+                    accounts = data["accounts"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from top level accounts",
+                        len(accounts),
+                    )
+                    return accounts
+                elif data.get("success") and isinstance(data.get("results"), list):
+                    accounts = data["results"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from top level results",
+                        len(accounts),
+                    )
+                    return accounts
+                elif data.get("success") and isinstance(data.get("entries"), list):
+                    accounts = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from top level entries",
+                        len(accounts),
+                    )
+                    return accounts
+                elif "accounts" in data and isinstance(data["accounts"], list):
+                    accounts = data["accounts"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from direct accounts field",
+                        len(accounts),
+                    )
+                    return accounts
+                elif "results" in data and isinstance(data["results"], list):
+                    accounts = data["results"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from direct results field",
+                        len(accounts),
+                    )
+                    return accounts
+                elif "entries" in data and isinstance(data["entries"], list):
+                    accounts = data["entries"]
+                    logger.info(
+                        "Successfully retrieved %d matching accounts from direct entries field",
+                        len(accounts),
+                    )
+                    return accounts
+                else:
+                    # If we can't find accounts in the expected structure, log the full response
+                    logger.error(
+                        "Could not find matching accounts 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 searching accounts: {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)}"