intentkit 0.6.21.dev2__tar.gz → 0.6.22.dev1__tar.gz

{intentkit-0.6.21.dev2 → intentkit-0.6.22.dev1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.21.dev2
+Version: 0.6.22.dev1
 Summary: Intent-based AI Agent Platform - Core Package
-Project-URL: Homepage, https://github.com/crestal-network/intentkit
-Project-URL: Repository, https://github.com/crestal-network/intentkit
-Project-URL: Documentation, https://github.com/crestal-network/intentkit/tree/main/docs
-Project-URL: Bug Tracker, https://github.com/crestal-network/intentkit/issues
+Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
+Project-URL: Repository, https://github.com/crestalnetwork/intentkit
+Project-URL: Documentation, https://github.com/crestalnetwork/intentkit/tree/main/docs
+Project-URL: Bug Tracker, https://github.com/crestalnetwork/intentkit/issues
 Author-email: hyacinthus <hyacinthus@gmail.com>
 License: MIT License
         

{intentkit-0.6.21.dev2 → intentkit-0.6.22.dev1}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.21-dev2"
+__version__ = "0.6.22-dev1"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

{intentkit-0.6.21.dev2 → intentkit-0.6.22.dev1}/models/agent_schema.json

@@ -682,7 +682,7 @@
       "description": "Ticker symbol of the agent",
       "maxLength": 10,
       "minLength": 1,
-      "x-group": "internal",
+      "x-group": "onchain",
       "x-placeholder": "Enter agent ticker"
     },
     "token_address": {
@@ -690,16 +690,14 @@
       "type": "string",
       "description": "Token address of the agent, if it already has one",
       "maxLength": 42,
-      "readOnly": true,
-      "x-group": "internal"
+      "x-group": "onchain"
     },
     "token_pool": {
       "title": "Token Pool",
       "type": "string",
       "description": "Pool of the agent token, if it has one",
       "maxLength": 42,
-      "readOnly": true,
-      "x-group": "internal"
+      "x-group": "onchain"
     }
   },
   "if": {

{intentkit-0.6.21.dev2 → intentkit-0.6.22.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.21-dev2"
+version = "0.6.22-dev1"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"
@@ -71,10 +71,10 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/crestal-network/intentkit"
-Repository = "https://github.com/crestal-network/intentkit"
-Documentation = "https://github.com/crestal-network/intentkit/tree/main/docs"
-"Bug Tracker" = "https://github.com/crestal-network/intentkit/issues"
+Homepage = "https://github.com/crestalnetwork/intentkit"
+Repository = "https://github.com/crestalnetwork/intentkit"
+Documentation = "https://github.com/crestalnetwork/intentkit/tree/main/docs"
+"Bug Tracker" = "https://github.com/crestalnetwork/intentkit/issues"
 
 [dependency-groups]
 dev = [

intentkit-0.6.22.dev1/skills/dexscreener/README.md

@@ -0,0 +1,154 @@
+# DexScreener Skill
+
+The DexScreener skill provides integration with the DexScreener API to search for cryptocurrency token pairs and retrieve market data including prices, volume, liquidity, and other trading metrics.
+
+## Overview
+
+DexScreener is a popular platform for tracking decentralized exchange (DEX) trading pairs across multiple blockchain networks. This skill enables your agent to search for token information and provide users with real-time market data.
+
+## Skills Available
+
+### `search_token`
+
+Searches DexScreener for token pairs matching a query string. Supports searching by:
+
+- Token symbol (e.g., "WIF", "DOGE")
+- Token name (e.g., "Dogwifhat")
+- Token address (e.g., "0x...")
+- Exact ticker matching with "$" prefix (e.g., "$WIF")
+- Pair address
+
+**Parameters:**
+
+- `query` (required): The search query string
+- `sort_by` (optional): Sort results by "liquidity" (default) or "volume"
+- `volume_timeframe` (optional): When sorting by volume, use "24_hour" (default), "6_hour", "1_hour", or "5_minutes"
+
+### `get_pair_info`
+
+Retrieves detailed information about a specific trading pair using chain ID and pair address.
+
+**Parameters:**
+
+- `chain_id` (required): The blockchain chain ID (e.g., "ethereum", "solana", "bsc", "polygon", "arbitrum", "base", "avalanche")
+- `pair_address` (required): The trading pair contract address
+
+### `get_token_pairs`
+
+Finds all trading pairs for a specific token using chain ID and token address.
+
+**Parameters:**
+
+- `chain_id` (required): The blockchain chain ID
+- `token_address` (required): The token contract address
+
+### `get_tokens_info`
+
+Retrieves detailed trading pair information for multiple tokens at once (up to 30 tokens).
+
+**Parameters:**
+
+- `chain_id` (required): The blockchain chain ID
+- `token_addresses` (required): List of token contract addresses (maximum 30)
+
+## Configuration
+
+Add to your agent configuration:
+
+```yaml
+skills:
+  dexscreener:
+    enabled: true
+    states:
+      search_token: public # or "private" or "disabled"
+      get_pair_info: public # or "private" or "disabled"
+      get_token_pairs: public # or "private" or "disabled"
+      get_tokens_info: public # or "private" or "disabled"
+```
+
+## Example Prompts
+
+Here are some example prompts that will trigger the DexScreener skill:
+
+### Basic Token Search
+
+- "What's the current price of WIF?"
+- "Show me information about Dogwifhat token"
+- "Find trading pairs for PEPE"
+- "Search for Solana tokens with high volume"
+
+### Address-Based Search
+
+- "Get token info for address 0x1234567890abcdef1234567890abcdef12345678"
+- "Look up this token contract: 0xabc123..."
+- "Find pairs for token address 0x..."
+
+### Exact Ticker Matching
+
+- "Show me all $WIF pairs" (matches only tokens with symbol "WIF")
+- "Find $DOGE trading data"
+- "$SOL price and volume information"
+
+### Sorting and Filtering
+
+- "Find highest volume tokens in the last hour"
+- "Show me tokens sorted by liquidity"
+- "Get 6-hour volume data for trending tokens"
+
+### Market Analysis
+
+- "What are the most liquid trading pairs right now?"
+- "Find new token launches with high volume"
+- "Show me tokens with significant price changes in the last 24 hours"
+- "Compare liquidity across different DEXes for a token"
+
+### Specific Pair Analysis
+
+- "Get detailed info for pair address 0x1234... on Ethereum"
+- "Show me the liquidity and volume for this Uniswap pair"
+- "Analyze this specific trading pair on Solana"
+- "What's the current price and 24h change for pair 0xabc..."
+
+### Token Pair Discovery
+
+- "Find all trading pairs for token 0x1234... on Ethereum"
+- "Where can I trade this token? Show me all available pairs"
+- "List all DEXes that have liquidity for this token address"
+- "Find the best liquidity pools for token 0xabc..."
+
+### Multi-Token Analysis
+
+- "Compare these 5 token addresses: [list of addresses]"
+- "Get trading data for my entire portfolio: [token addresses]"
+- "Analyze liquidity across these tokens on Ethereum"
+- "Show me pair information for these 10 tokens at once"
+
+### Portfolio Research
+
+- "Research this token before I invest: [token name/symbol]"
+- "Is this token legitimate? Check its social links"
+- "What DEXes is this token trading on?"
+- "Show me the trading activity for this pair"
+
+## Response Format
+
+The skill returns structured JSON data containing:
+
+- Token pair information (base/quote tokens)
+- Current prices in USD and native currency
+- Volume data across different timeframes
+- Liquidity information
+- Price change percentages
+- Market cap and fully diluted valuation
+- Social links and website information
+- Trading transaction counts
+
+## Rate Limits
+
+- 300 requests per minute across all users
+- Built-in rate limiting prevents exceeding API limits
+- Requests are queued and processed efficiently
+
+## Data Sources
+
+All data is sourced from the official DexScreener API, which aggregates information from major decentralized exchanges across multiple blockchain networks including Ethereum, Solana, Binance Smart Chain, and others.

{intentkit-0.6.21.dev2 → intentkit-0.6.22.dev1}/skills/dexscreener/__init__.py

@@ -4,6 +4,9 @@ from typing import Optional, TypedDict
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.dexscreener.base import DexScreenerBaseTool
+from intentkit.skills.dexscreener.get_pair_info import GetPairInfo
+from intentkit.skills.dexscreener.get_token_pairs import GetTokenPairs
+from intentkit.skills.dexscreener.get_tokens_info import GetTokensInfo
 from intentkit.skills.dexscreener.search_token import SearchToken
 
 # Cache skills at the system level, because they are stateless
@@ -14,10 +17,16 @@ logger = logging.getLogger(__name__)
 
 class SkillStates(TypedDict):
     search_token: SkillState
+    get_pair_info: SkillState
+    get_token_pairs: SkillState
+    get_tokens_info: SkillState
 
 
 _SKILL_NAME_TO_CLASS_MAP: dict[str, type[DexScreenerBaseTool]] = {
     "search_token": SearchToken,
+    "get_pair_info": GetPairInfo,
+    "get_token_pairs": GetTokenPairs,
+    "get_tokens_info": GetTokensInfo,
 }
 
 

{intentkit-0.6.21.dev2 → intentkit-0.6.22.dev1}/skills/dexscreener/base.py

@@ -7,13 +7,10 @@ from pydantic import Field
 
 from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.dexscreener.utils import DEXSCREENER_BASE_URL
 
 logger = logging.getLogger(__name__)
 
-DEXSCREENER_BASE_URL = "https://api.dexscreener.com"
-
-# Removed DexScreenerApiError as it won't be raised by _get anymore
-
 # ApiResult still represents (success_data, error_data)
 ApiResult = Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]
 

intentkit-0.6.22.dev1/skills/dexscreener/get_pair_info.py

@@ -0,0 +1,159 @@
+import logging
+from typing import Any, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.dexscreener.base import DexScreenerBaseTool
+from intentkit.skills.dexscreener.model.search_token_response import PairModel
+from intentkit.skills.dexscreener.utils import (
+    API_ENDPOINTS,
+    RATE_LIMITS,
+    create_error_response,
+    format_success_response,
+    truncate_large_fields,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GetPairInfoInput(BaseModel):
+    """Input schema for the DexScreener get_pair_info tool."""
+
+    chain_id: str = Field(
+        description="The blockchain chain ID (e.g., 'ethereum', 'solana', 'bsc', 'polygon', 'arbitrum', 'base', 'avalanche')"
+    )
+    pair_address: str = Field(
+        description="The trading pair contract address (e.g., '0x1234...abcd' for Ethereum-based chains)"
+    )
+
+
+class GetPairInfo(DexScreenerBaseTool):
+    """
+    Tool to get detailed information about a specific trading pair on DexScreener.
+    """
+
+    name: str = "dexscreener_get_pair_info"
+    description: str = (
+        "Retrieves detailed information about a specific trading pair using chain ID and pair address. "
+        "Returns comprehensive data including current price, volume, liquidity, price changes, "
+        "market cap, FDV, transaction counts, and social links. "
+        "Use this tool when you have a specific pair address and need detailed trading metrics."
+    )
+    args_schema: Type[BaseModel] = GetPairInfoInput
+
+    async def _arun(
+        self,
+        chain_id: str,
+        pair_address: str,
+        **kwargs: Any,
+    ) -> str:
+        """Implementation to get specific pair information."""
+
+        # Apply rate limiting
+        await self.user_rate_limit_by_category(
+            user_id=f"{self.category}{self.name}",
+            limit=RATE_LIMITS["pairs"],
+            minutes=1,
+        )
+
+        logger.info(
+            f"Executing DexScreener get_pair_info tool with chain_id: '{chain_id}', "
+            f"pair_address: '{pair_address}'"
+        )
+
+        try:
+            # Construct API path
+            api_path = f"{API_ENDPOINTS['pairs']}/{chain_id}/{pair_address}"
+
+            data, error_details = await self._get(path=api_path)
+
+            if error_details:
+                return await self._handle_error_response(error_details)
+
+            if not data:
+                logger.error(f"No data returned for pair {pair_address} on {chain_id}")
+                return create_error_response(
+                    error_type="empty_success",
+                    message="API call returned empty success response.",
+                    additional_data={
+                        "chain_id": chain_id,
+                        "pair_address": pair_address,
+                    },
+                )
+
+            # The API returns a single pair object, not wrapped in a pairs array
+            if not isinstance(data, dict):
+                return create_error_response(
+                    error_type="format_error",
+                    message="Unexpected response format - expected object",
+                    additional_data={
+                        "chain_id": chain_id,
+                        "pair_address": pair_address,
+                    },
+                )
+
+            try:
+                # Validate the response using our existing PairModel
+                pair_data = PairModel.model_validate(data)
+                logger.info(
+                    f"Successfully retrieved pair info for {pair_address} on {chain_id}"
+                )
+
+                return format_success_response(
+                    {
+                        "pair": pair_data.model_dump(),
+                        "chain_id": chain_id,
+                        "pair_address": pair_address,
+                    }
+                )
+
+            except Exception as validation_error:
+                logger.error(
+                    f"Failed to validate pair response for {pair_address} on {chain_id}: {validation_error}",
+                    exc_info=True,
+                )
+                # Return raw data if validation fails
+                return format_success_response(
+                    {
+                        "pair": data,
+                        "chain_id": chain_id,
+                        "pair_address": pair_address,
+                        "validation_warning": "Response structure may have changed",
+                    }
+                )
+
+        except Exception as e:
+            return await self._handle_unexpected_runtime_error(
+                e, f"{chain_id}/{pair_address}"
+            )
+
+    async def _handle_error_response(self, error_details: dict) -> str:
+        """Formats error details (from _get) into a JSON string."""
+        if error_details.get("error_type") in [
+            "connection_error",
+            "parsing_error",
+            "unexpected_error",
+        ]:
+            logger.error(
+                f"DexScreener get_pair_info tool encountered an error: {error_details}"
+            )
+        else:  # api_error
+            logger.warning(f"DexScreener API returned an error: {error_details}")
+
+        # Truncate potentially large fields before returning to user/LLM
+        truncated_details = truncate_large_fields(error_details)
+        return format_success_response(truncated_details)
+
+    async def _handle_unexpected_runtime_error(
+        self, e: Exception, query_info: str
+    ) -> str:
+        """Formats unexpected runtime exception details into a JSON string."""
+        logger.exception(
+            f"An unexpected runtime error occurred in get_pair_info tool _arun method for {query_info}: {e}"
+        )
+        return create_error_response(
+            error_type="runtime_error",
+            message="An unexpected internal error occurred processing the pair info request",
+            details=str(e),
+            additional_data={"query_info": query_info},
+        )

intentkit-0.6.22.dev1/skills/dexscreener/get_token_pairs.py

@@ -0,0 +1,166 @@
+import logging
+from typing import Any, Type
+
+from pydantic import BaseModel, Field, ValidationError
+
+from intentkit.skills.dexscreener.base import DexScreenerBaseTool
+from intentkit.skills.dexscreener.model.search_token_response import (
+    SearchTokenResponseModel,
+)
+from intentkit.skills.dexscreener.utils import (
+    API_ENDPOINTS,
+    RATE_LIMITS,
+    create_error_response,
+    create_no_results_response,
+    format_success_response,
+    get_liquidity_value,
+    handle_validation_error,
+    truncate_large_fields,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GetTokenPairsInput(BaseModel):
+    """Input schema for the DexScreener get_token_pairs tool."""
+
+    chain_id: str = Field(
+        description="The blockchain chain ID (e.g., 'ethereum', 'solana', 'bsc', 'polygon', 'arbitrum', 'base', 'avalanche')"
+    )
+    token_address: str = Field(
+        description="The token contract address (e.g., '0x1234...abcd' for Ethereum-based chains)"
+    )
+
+
+class GetTokenPairs(DexScreenerBaseTool):
+    """
+    Tool to get all trading pairs for a specific token on DexScreener.
+    """
+
+    name: str = "dexscreener_get_token_pairs"
+    description: str = (
+        "Finds all trading pairs for a specific token using chain ID and token address. "
+        "Returns a list of all pools/pairs where this token is traded, including pair addresses, "
+        "DEX information, liquidity, volume, and pricing data for each pair. "
+        "Use this tool to analyze all available trading venues and liquidity sources for a specific token."
+    )
+    args_schema: Type[BaseModel] = GetTokenPairsInput
+
+    async def _arun(
+        self,
+        chain_id: str,
+        token_address: str,
+        **kwargs: Any,
+    ) -> str:
+        """Implementation to get all pairs for a specific token."""
+
+        # Apply rate limiting
+        await self.user_rate_limit_by_category(
+            user_id=f"{self.category}{self.name}",
+            limit=RATE_LIMITS["token_pairs"],
+            minutes=1,
+        )
+
+        logger.info(
+            f"Executing DexScreener get_token_pairs tool with chain_id: '{chain_id}', "
+            f"token_address: '{token_address}'"
+        )
+
+        try:
+            # Construct API path
+            api_path = f"{API_ENDPOINTS['token_pairs']}/{chain_id}/{token_address}"
+
+            data, error_details = await self._get(path=api_path)
+
+            if error_details:
+                return await self._handle_error_response(error_details)
+
+            if not data:
+                logger.error(
+                    f"No data returned for token {token_address} on {chain_id}"
+                )
+                return create_error_response(
+                    error_type="empty_success",
+                    message="API call returned empty success response.",
+                    additional_data={
+                        "chain_id": chain_id,
+                        "token_address": token_address,
+                    },
+                )
+
+            try:
+                # Validate response using SearchTokenResponseModel since API returns similar structure
+                result = SearchTokenResponseModel.model_validate(data)
+            except ValidationError as e:
+                return handle_validation_error(
+                    e, f"{chain_id}/{token_address}", len(str(data))
+                )
+
+            if not result.pairs:
+                return create_no_results_response(
+                    f"{chain_id}/{token_address}",
+                    reason="no trading pairs found for this token",
+                )
+
+            pairs_list = [p for p in result.pairs if p is not None]
+
+            if not pairs_list:
+                return create_no_results_response(
+                    f"{chain_id}/{token_address}",
+                    reason="all pairs were null or invalid",
+                )
+
+            # Sort pairs by liquidity (highest first) for better UX
+            try:
+                pairs_list.sort(key=get_liquidity_value, reverse=True)
+            except Exception as sort_err:
+                logger.warning(f"Failed to sort pairs by liquidity: {sort_err}")
+
+            logger.info(
+                f"Found {len(pairs_list)} pairs for token {token_address} on {chain_id}"
+            )
+
+            return format_success_response(
+                {
+                    "pairs": [p.model_dump() for p in pairs_list],
+                    "chain_id": chain_id,
+                    "token_address": token_address,
+                    "total_pairs": len(pairs_list),
+                }
+            )
+
+        except Exception as e:
+            return await self._handle_unexpected_runtime_error(
+                e, f"{chain_id}/{token_address}"
+            )
+
+    async def _handle_error_response(self, error_details: dict) -> str:
+        """Formats error details (from _get) into a JSON string."""
+        if error_details.get("error_type") in [
+            "connection_error",
+            "parsing_error",
+            "unexpected_error",
+        ]:
+            logger.error(
+                f"DexScreener get_token_pairs tool encountered an error: {error_details}"
+            )
+        else:  # api_error
+            logger.warning(f"DexScreener API returned an error: {error_details}")
+
+        # Truncate potentially large fields before returning to user/LLM
+        truncated_details = truncate_large_fields(error_details)
+        return format_success_response(truncated_details)
+
+    async def _handle_unexpected_runtime_error(
+        self, e: Exception, query_info: str
+    ) -> str:
+        """Formats unexpected runtime exception details into a JSON string."""
+        logger.exception(
+            f"An unexpected runtime error occurred in get_token_pairs tool _arun method for {query_info}: {e}"
+        )
+        return create_error_response(
+            error_type="runtime_error",
+            message="An unexpected internal error occurred processing the token pairs request",
+            details=str(e),
+            additional_data={"query_info": query_info},
+        )