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

intentkit/skills/chainlist/chain_lookup.py

@@ -0,0 +1,208 @@
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+import httpx
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.chainlist.base import ChainlistBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class ChainLookupInput(BaseModel):
+    """Input for ChainLookup tool."""
+
+    search_term: Optional[str] = Field(
+        description="Term to search for (chain name, symbol, or chain ID)",
+        default=None,
+    )
+    chain_id: Optional[int] = Field(
+        description="Specific chain ID to look up",
+        default=None,
+    )
+    no_tracking: Optional[bool] = Field(
+        description="Whether to return only RPC endpoints with no tracking",
+        default=False,
+    )
+    limit: Optional[int] = Field(
+        description="Limit the number of results returned",
+        default=5,
+    )
+
+
+class ChainLookup(ChainlistBaseTool):
+    """Tool for looking up blockchain RPC endpoints from Chainlist."""
+
+    name: str = "chain_lookup"
+    description: str = (
+        "Look up blockchain RPC endpoints and details by chain name, symbol, or chain ID.\n"
+        "Returns information about blockchains including RPC endpoints, native currency, and explorers."
+    )
+    args_schema: Type[BaseModel] = ChainLookupInput
+
+    def _normalize_text(self, text: str) -> str:
+        """Normalize text for searching (lowercase, remove spaces)."""
+        if not text:
+            return ""
+        return text.lower().strip()
+
+    async def _fetch_chains_data(self) -> List[Dict[str, Any]]:
+        """Fetch chains data from Chainlist API."""
+        chainlist_api_url = "https://chainlist.org/rpcs.json"
+
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(chainlist_api_url)
+            response.raise_for_status()
+            return response.json()
+
+    def _filter_chains(
+        self,
+        chains: List[Dict[str, Any]],
+        search_term: Optional[str] = None,
+        chain_id: Optional[int] = None,
+        no_tracking: bool = False,
+        limit: int = 5,
+    ) -> List[Dict[str, Any]]:
+        """Filter chains based on search criteria."""
+        filtered_chains = chains
+
+        # Filter by chain_id if provided
+        if chain_id is not None:
+            filtered_chains = [
+                chain for chain in filtered_chains if chain.get("chainId") == chain_id
+            ]
+
+        # Filter by search term if provided
+        if search_term and chain_id is None:
+            normalized_term = self._normalize_text(search_term)
+            result = []
+
+            for chain in filtered_chains:
+                name = self._normalize_text(chain.get("name", ""))
+                symbol = self._normalize_text(chain.get("chain", ""))
+                short_name = self._normalize_text(chain.get("shortName", ""))
+
+                if (
+                    normalized_term in name
+                    or normalized_term in symbol
+                    or normalized_term in short_name
+                ):
+                    result.append(chain)
+
+            filtered_chains = result
+
+        # Filter RPC endpoints for each chain if no_tracking is True
+        if no_tracking:
+            filtered_result = []
+            for chain in filtered_chains:
+                if "rpc" not in chain:
+                    continue
+
+                chain_copy = dict(chain)
+                chain_copy["rpc"] = [
+                    rpc
+                    for rpc in chain["rpc"]
+                    if isinstance(rpc, dict) and rpc.get("tracking") == "none"
+                ]
+
+                if chain_copy[
+                    "rpc"
+                ]:  # Only include if it has RPC endpoints after filtering
+                    filtered_result.append(chain_copy)
+
+            filtered_chains = filtered_result
+
+        # Apply limit
+        if limit > 0:
+            filtered_chains = filtered_chains[:limit]
+
+        return filtered_chains
+
+    def _format_chain(self, chain: Dict[str, Any]) -> Dict[str, Any]:
+        """Format a chain entry for response."""
+        # Format RPC endpoints
+        formatted_rpcs = []
+        if "rpc" in chain:
+            for rpc in chain["rpc"]:
+                if isinstance(rpc, dict):
+                    url = rpc.get("url")
+                    tracking = rpc.get("tracking", "unspecified")
+                    formatted_rpcs.append({"url": url, "tracking": tracking})
+                elif isinstance(rpc, str):
+                    formatted_rpcs.append({"url": rpc, "tracking": "unspecified"})
+
+        # Format chain data
+        formatted_chain = {
+            "name": chain.get("name"),
+            "chain": chain.get("chain"),
+            "chainId": chain.get("chainId"),
+            "networkId": chain.get("networkId"),
+            "shortName": chain.get("shortName"),
+            "infoURL": chain.get("infoURL", ""),
+            "nativeCurrency": chain.get("nativeCurrency", {}),
+            "rpc": formatted_rpcs[:3],  # Limit to 3 RPC endpoints per chain
+            "total_rpc_count": len(chain.get("rpc", [])),
+        }
+
+        # Add explorers if available
+        if "explorers" in chain and chain["explorers"]:
+            formatted_chain["explorers"] = [
+                {"name": explorer.get("name", ""), "url": explorer.get("url", "")}
+                for explorer in chain["explorers"][:2]  # Limit to 2 explorers
+            ]
+
+        return formatted_chain
+
+    async def _arun(
+        self,
+        search_term: Optional[str] = None,
+        chain_id: Optional[int] = None,
+        no_tracking: Optional[bool] = False,
+        limit: Optional[int] = 5,
+        config: Optional[RunnableConfig] = None,
+        **kwargs,
+    ) -> Dict:
+        """Lookup blockchain RPC endpoints from Chainlist."""
+        if not search_term and not chain_id:
+            return {
+                "error": "Please provide either a search term or a chain ID to lookup."
+            }
+
+        try:
+            # Fetch data
+            chains_data = await self._fetch_chains_data()
+
+            # Filter chains based on criteria
+            filtered_chains = self._filter_chains(
+                chains_data,
+                search_term=search_term,
+                chain_id=chain_id,
+                no_tracking=no_tracking,
+                limit=limit,
+            )
+
+            # Handle no results
+            if not filtered_chains:
+                return {
+                    "found": False,
+                    "message": "No chains found matching the search criteria.",
+                }
+
+            # Format results
+            formatted_chains = [self._format_chain(chain) for chain in filtered_chains]
+
+            return {
+                "found": True,
+                "count": len(formatted_chains),
+                "chains": formatted_chains,
+            }
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error fetching chain data: {e}")
+            return {
+                "error": f"Error fetching chain data: HTTP status code {e.response.status_code}"
+            }
+        except Exception as e:
+            logger.error(f"Error fetching chain data: {str(e)}")
+            return {"error": f"An error occurred while fetching chain data: {str(e)}"}

intentkit/skills/chainlist/schema.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Chainlist Skills",
+  "description": "Access blockchain RPC endpoints and network information from chainlist.org. Enable this skill to look up EVM-compatible networks by name, symbol, or chain ID and get their RPC endpoints, native currencies, and explorer links.",
+  "x-icon": "https://ai.service.crestal.dev/skills/chainlist/chainlist.png",
+  "x-tags": [
+    "Blockchain",
+    "RPC",
+    "EVM",
+    "Network"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "default": false
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "chain_lookup": {
+          "type": "string",
+          "title": "Chain Lookup",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Enables looking up blockchain RPC endpoints and network information. When public, available to all users; when private, only to authenticated users.",
+          "default": "disabled"
+        }
+      },
+      "description": "Configure visibility for chainlist skills (disabled: unavailable, public: available to all, private: available only to authenticated users)"
+    }
+  },
+  "required": [
+    "enabled",
+    "states"
+  ],
+  "additionalProperties": true
+}

intentkit/skills/common/__init__.py

@@ -0,0 +1,82 @@
+"""Common utility skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.common.base import CommonBaseTool
+from intentkit.skills.common.current_time import CurrentTime
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, CommonBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    current_time: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for common utility skills."""
+
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[CommonBaseTool]:
+    """Get all common utility skills.
+
+    Args:
+        config: The configuration for common utility skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of common utility 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_common_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_common_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> CommonBaseTool:
+    """Get a common utility skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested common utility skill
+    """
+    if name == "current_time":
+        if name not in _cache:
+            _cache[name] = CurrentTime(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown common skill: {name}")
+        return None

intentkit/skills/common/base.py

@@ -0,0 +1,21 @@
+from typing import Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+
+class CommonBaseTool(IntentKitSkill):
+    """Base class for common utility 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 "common"

intentkit/skills/common/current_time.py

@@ -0,0 +1,84 @@
+import logging
+from datetime import datetime
+from typing import Type
+
+import pytz
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.common.base import CommonBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class CurrentTimeInput(BaseModel):
+    """Input for CurrentTime tool."""
+
+    timezone: str = Field(
+        description="Timezone to format the time in (e.g., 'UTC', 'US/Pacific', 'Europe/London', 'Asia/Tokyo'). Default is UTC.",
+        default="UTC",
+    )
+
+
+class CurrentTime(CommonBaseTool):
+    """Tool for getting the current time.
+
+    This tool returns the current time and converts it to the specified timezone.
+    By default, it returns the time in UTC.
+
+    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 = "common_current_time"
+    description: str = (
+        "Get the current time, converted to a specified timezone.\n"
+        "You must call this tool whenever the user asks for the time."
+    )
+    args_schema: Type[BaseModel] = CurrentTimeInput
+
+    async def _arun(self, timezone: str, config: RunnableConfig, **kwargs) -> str:
+        """Implementation of the tool to get the current time.
+
+        Args:
+            timezone (str): The timezone to format the time in. Defaults to "UTC".
+
+        Returns:
+            str: A formatted string with the current time in the specified timezone.
+        """
+        # Get current UTC time
+        utc_now = datetime.now(pytz.UTC)
+
+        # Convert to the requested timezone
+        if timezone.upper() != "UTC":
+            try:
+                tz = pytz.timezone(timezone)
+                converted_time = utc_now.astimezone(tz)
+            except pytz.exceptions.UnknownTimeZoneError:
+                # Provide some suggestions for common timezones
+                common_timezones = [
+                    "US/Eastern",
+                    "US/Central",
+                    "US/Pacific",
+                    "Europe/London",
+                    "Europe/Paris",
+                    "Europe/Berlin",
+                    "Asia/Shanghai",
+                    "Asia/Tokyo",
+                    "Asia/Singapore",
+                    "Australia/Sydney",
+                ]
+                suggestion_str = ", ".join([f"'{tz}'" for tz in common_timezones])
+                return (
+                    f"Error: Unknown timezone '{timezone}'. Using UTC instead.\n"
+                    f"Some common timezone options: {suggestion_str}"
+                )
+        else:
+            converted_time = utc_now
+
+        # Format the time
+        formatted_time = converted_time.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+        return f"Current time: {formatted_time}"

intentkit/skills/common/schema.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Common Utilities",
+  "description": "Utility skills",
+  "x-icon": "https://ai.service.crestal.dev/skills/common/common.jpg",
+  "x-tags": [
+    "Utility"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": true
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "current_time": {
+          "type": "string",
+          "title": "Current Time",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Provides localized timekeeping with automatic timezone detection using IP geolocation",
+          "default": "private"
+        }
+      },
+      "description": "States for each common utility skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Who provides the API key",
+      "enum": [
+        "platform"
+      ],
+      "x-enum-title": [
+        "Nation Hosted"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "additionalProperties": true
+}

intentkit/skills/cookiefun/README.md

@@ -0,0 +1,121 @@
+# CookieFun Skills
+
+This skill category provides access to CookieFun API for Twitter/X analytics and account insights.
+
+### Features
+
+The CookieFun skills allow you to:
+
+- Get a list of all available sectors
+- Get detailed information about Twitter accounts
+- Get the feed of tweets from specific accounts
+- Find smart followers for Twitter accounts
+- Search for Twitter accounts matching specific criteria
+
+### API Key
+
+You need a CookieFun API key to use these skills. You can get one by signing up at [CookieFun](https://cookie.fun/).
+
+### Skills
+
+#### Get Sectors
+
+Returns a list of all available sectors in the CookieFun system.
+
+Example usage:
+```
+Call the get_sectors skill to fetch all sectors available in the CookieFun system.
+```
+
+Example prompts:
+- "What sectors are available in CookieFun?"
+- "Show me all the sectors in CookieFun"
+- "Get a list of all sectors from CookieFun"
+
+#### Get Account Details
+
+Retrieves detailed information about a Twitter account including followers, following, posts, metrics, and engagement data.
+
+Example usage:
+```
+Call the get_account_details skill with parameters:
+- username: "elonmusk" 
+```
+
+or 
+
+```
+Call the get_account_details skill with parameters:
+- userId: "1234567890"
+```
+
+Example prompts:
+- "Get details about the Twitter account @elonmusk"
+- "Fetch information about Elon Musk's Twitter profile"
+- "Show me stats for the Twitter user elonmusk"
+- "What's the engagement rate for @elonmusk?"
+
+#### Get Account Smart Followers
+
+Returns a list of top smart followers for a specific Twitter account, with detailed metrics about these followers.
+
+Example usage:
+```
+Call the get_account_smart_followers skill with parameters:
+- username: "elonmusk"
+```
+
+or
+
+```
+Call the get_account_smart_followers skill with parameters:
+- userId: "1234567890"
+```
+
+Example prompts:
+- "Who are the top smart followers of @elonmusk?"
+- "Get me a list of the most influential followers of Elon Musk"
+- "Show me the smart followers for Twitter user elonmusk"
+- "Find the most engaged followers of @elonmusk"
+
+#### Search Accounts
+
+Searches for Twitter accounts that authored tweets matching specified search criteria.
+
+Example usage:
+```
+Call the search_accounts skill with parameters:
+- searchQuery: "bitcoin"
+- type: 0  # Optional: 0 for Original, 1 for Reply, 2 for Quote
+- sortBy: 0  # Optional: 0 for SmartEngagementPoints, 1 for Impressions, 2 for MatchingTweetsCount
+- sortOrder: 1  # Optional: 0 for Ascending, 1 for Descending
+```
+
+Example prompts:
+- "Find Twitter accounts talking about bitcoin"
+- "Search for accounts that tweet about AI sorted by engagement"
+- "Who are the top accounts posting original tweets about NFTs?"
+- "Find Twitter users discussing climate change with the most impressions"
+
+#### Get Account Feed
+
+Retrieves a list of tweets for a specific Twitter account with various filtering options.
+
+Example usage:
+```
+Call the get_account_feed skill with parameters:
+- username: "elonmusk"
+- startDate: "01/05/2023"  # Optional: Filter tweets after this date
+- endDate: "31/05/2023"  # Optional: Filter tweets before this date
+- type: 0  # Optional: 0 for Original, 1 for Reply, 2 for Quote
+- hasMedia: true  # Optional: Filter to only tweets with media
+- sortBy: 0  # Optional: 0 for CreatedDate, 1 for Impressions
+- sortOrder: 1  # Optional: 0 for Ascending, 1 for Descending
+```
+
+Example prompts:
+- "Show me Elon Musk's tweets from May 2023"
+- "Get the most popular tweets from @elonmusk"
+- "Fetch only original tweets (not replies) from elonmusk"
+- "Show me tweets with media from @elonmusk posted in the last month"
+- "What are the latest tweets from Elon Musk sorted by impressions?"