intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/skills/defillama/yields/fetch_pools.py

@@ -1,7 +1,5 @@
 """Tool for fetching pool data via DeFi Llama API."""
 
-from typing import Optional
-
 from pydantic import BaseModel, Field
 
 from intentkit.skills.defillama.api import fetch_pools
@@ -21,13 +19,13 @@ Returns data including:
 class PredictionData(BaseModel):
     """Model representing prediction data for a pool."""
 
-    predictedClass: Optional[str] = Field(
+    predictedClass: str | None = Field(
         None, description="Predicted direction of APY movement"
     )
-    predictedProbability: Optional[float] = Field(
+    predictedProbability: float | None = Field(
         None, description="Probability of the prediction"
     )
-    binnedConfidence: Optional[int] = Field(None, description="Confidence level bucket")
+    binnedConfidence: int | None = Field(None, description="Confidence level bucket")
 
 
 class PoolData(BaseModel):
@@ -37,38 +35,36 @@ class PoolData(BaseModel):
     project: str = Field(..., description="Protocol or project name")
     symbol: str = Field(..., description="Token or pool symbol")
     tvlUsd: float = Field(..., description="Total Value Locked in USD")
-    apyBase: Optional[float] = Field(None, description="Base APY without rewards")
-    apyReward: Optional[float] = Field(None, description="Additional APY from rewards")
-    apy: Optional[float] = Field(None, description="Total APY including rewards")
-    rewardTokens: Optional[list[str]] = Field(
+    apyBase: float | None = Field(None, description="Base APY without rewards")
+    apyReward: float | None = Field(None, description="Additional APY from rewards")
+    apy: float | None = Field(None, description="Total APY including rewards")
+    rewardTokens: list[str] | None = Field(
         None, description="List of reward token addresses"
     )
-    pool: Optional[str] = Field(None, description="Pool identifier")
-    apyPct1D: Optional[float] = Field(None, description="1-day APY percentage change")
-    apyPct7D: Optional[float] = Field(None, description="7-day APY percentage change")
-    apyPct30D: Optional[float] = Field(None, description="30-day APY percentage change")
+    pool: str | None = Field(None, description="Pool identifier")
+    apyPct1D: float | None = Field(None, description="1-day APY percentage change")
+    apyPct7D: float | None = Field(None, description="7-day APY percentage change")
+    apyPct30D: float | None = Field(None, description="30-day APY percentage change")
     stablecoin: bool = Field(False, description="Whether pool involves stablecoins")
     ilRisk: str = Field("no", description="Impermanent loss risk assessment")
     exposure: str = Field("single", description="Asset exposure type")
-    predictions: Optional[PredictionData] = Field(
+    predictions: PredictionData | None = Field(
         None, description="APY movement predictions"
     )
-    poolMeta: Optional[str] = Field(None, description="Additional pool metadata")
-    mu: Optional[float] = Field(None, description="Mean APY value")
-    sigma: Optional[float] = Field(None, description="APY standard deviation")
-    count: Optional[int] = Field(None, description="Number of data points")
+    poolMeta: str | None = Field(None, description="Additional pool metadata")
+    mu: float | None = Field(None, description="Mean APY value")
+    sigma: float | None = Field(None, description="APY standard deviation")
+    count: int | None = Field(None, description="Number of data points")
     outlier: bool = Field(False, description="Whether pool is an outlier")
-    underlyingTokens: Optional[list[str]] = Field(
+    underlyingTokens: list[str] | None = Field(
         None, description="List of underlying token addresses"
     )
-    il7d: Optional[float] = Field(None, description="7-day impermanent loss")
-    apyBase7d: Optional[float] = Field(None, description="7-day base APY")
-    apyMean30d: Optional[float] = Field(None, description="30-day mean APY")
-    volumeUsd1d: Optional[float] = Field(None, description="24h volume in USD")
-    volumeUsd7d: Optional[float] = Field(None, description="7-day volume in USD")
-    apyBaseInception: Optional[float] = Field(
-        None, description="Base APY since inception"
-    )
+    il7d: float | None = Field(None, description="7-day impermanent loss")
+    apyBase7d: float | None = Field(None, description="7-day base APY")
+    apyMean30d: float | None = Field(None, description="30-day mean APY")
+    volumeUsd1d: float | None = Field(None, description="24h volume in USD")
+    volumeUsd7d: float | None = Field(None, description="7-day volume in USD")
+    apyBaseInception: float | None = Field(None, description="Base APY since inception")
 
 
 class FetchPoolsResponse(BaseModel):
@@ -76,7 +72,7 @@ class FetchPoolsResponse(BaseModel):
 
     status: str = Field("success", description="Response status")
     data: list[PoolData] = Field(default_factory=list, description="List of pool data")
-    error: Optional[str] = Field(None, description="Error message if any")
+    error: str | None = Field(None, description="Error message if any")
 
 
 class DefiLlamaFetchPools(DefiLlamaBaseTool):
@@ -87,9 +83,9 @@ class DefiLlamaFetchPools(DefiLlamaBaseTool):
 
     Example:
         pools_tool = DefiLlamaFetchPools(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await pools_tool._arun()
     """

intentkit/skills/dexscreener/__init__.py

@@ -1,102 +1,97 @@
-import logging
-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
-_cache: dict[str, DexScreenerBaseTool] = {}
-
-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,
-}
-
-
-class Config(SkillConfig):
-    """Configuration for DexScreener skills."""
-
-    enabled: bool
-    states: SkillStates
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,
-) -> list[DexScreenerBaseTool]:
-    """Get all DexScreener skills.
-
-    Args:
-        config: The configuration for DexScreener skills.
-        is_private: Whether to include private skills.
-        store: The skill store for persisting data.
-
-    Returns:
-        A list of DexScreener 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)
-
-    logger.debug(f"Available Skills {available_skills}")
-    logger.debug(f"Hardcoded Skills {_SKILL_NAME_TO_CLASS_MAP}")
-
-    # Get each skill using the cached getter
-    result = []
-    for name in available_skills:
-        skill = get_dexscreener_skills(name, store)
-        if skill:
-            result.append(skill)
-    return result
-
-
-def get_dexscreener_skills(
-    name: str,
-    store: SkillStoreABC,
-) -> Optional[DexScreenerBaseTool]:
-    """Get a DexScreener skill by name.
-
-    Args:
-        name: The name of the skill to get
-        store: The skill store for persisting data
-
-    Returns:
-        The requested DexScreener skill
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
-    if not skill_class:
-        logger.warning(f"Unknown Dexscreener skill: {name}")
-        return None
-
-    _cache[name] = skill_class(skill_store=store)
-    return _cache[name]
+import logging
+from typing import TypedDict
+
+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
+_cache: dict[str, DexScreenerBaseTool] = {}
+
+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,
+}
+
+
+class Config(SkillConfig):
+    """Configuration for DexScreener skills."""
+
+    enabled: bool
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,
+) -> list[DexScreenerBaseTool]:
+    """Get all DexScreener skills.
+
+    Args:
+        config: The configuration for DexScreener skills.
+        is_private: Whether to include private skills.
+
+    Returns:
+        A list of DexScreener 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)
+
+    logger.debug(f"Available Skills {available_skills}")
+    logger.debug(f"Hardcoded Skills {_SKILL_NAME_TO_CLASS_MAP}")
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_dexscreener_skills(name)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_dexscreener_skills(
+    name: str,
+) -> DexScreenerBaseTool | None:
+    """Get a DexScreener skill by name.
+
+    Args:
+        name: The name of the skill to get
+
+    Returns:
+        The requested DexScreener skill
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
+    if not skill_class:
+        logger.warning(f"Unknown Dexscreener skill: {name}")
+        return None
+
+    _cache[name] = skill_class()
+    return _cache[name]

intentkit/skills/dexscreener/base.py

@@ -1,130 +1,125 @@
-import json
-import logging
-from typing import Any, Dict, Optional, Tuple
-
-import httpx
-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__)
-
-# ApiResult still represents (success_data, error_data)
-ApiResult = Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]
-
-
-class DexScreenerBaseTool(IntentKitSkill):
-    """
-    Generic base class for tools interacting with the Dex Screener API.
-    Handles shared logic like API calls and error reporting via return values.
-    """
-
-    skill_store: SkillStoreABC = Field(
-        description="The skill store for persisting data and configs."
-    )
-    base_url: str = DEXSCREENER_BASE_URL
-
-    @property
-    def category(self) -> str:
-        return "dexscreener"
-
-    async def _get(
-        self,
-        path: str,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> ApiResult:
-        """
-        Makes an asynchronous GET request to the DexScreener API.
-
-        Args:
-            path: The API endpoint path (e.g., "/dex/search").
-            params: Optional dictionary of query parameters.
-
-        Returns:
-            A tuple (data, error_details):
-            - (dict, None): On HTTP 2xx success with valid JSON response.
-            - (None, dict): On any error (API error, connection error,
-                            JSON parsing error, unexpected error). The dict
-                            contains details including an 'error_type'.
-        """
-        if not path.startswith("/"):
-            path = "/" + path
-
-        url = f"{self.base_url}{path}"
-        headers = {"Accept": "application/json"}
-        method = "GET"
-
-        logger.debug(f"Calling DexScreener API: {method} {url} with params: {params}")
-        response = None  # Define response outside try block for access in except
-
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.request(
-                    method, url, params=params, headers=headers
-                )
-
-                # Attempt to parse JSON response text
-                try:
-                    response_data = response.json()
-                except json.JSONDecodeError as json_err:
-                    logger.error(
-                        f"Failed to parse JSON response from {url}. Status: {response.status_code}. Response text: {response.text}",
-                        exc_info=True,
-                    )
-                    error_details = {
-                        "error": "Failed to parse DexScreener API response",
-                        "error_type": "parsing_error",
-                        "status_code": response.status_code,
-                        "details": response.text,  # Raw text causing the error
-                        "original_exception": str(json_err),
-                        "url": url,
-                    }
-                    return None, error_details  # Return parsing error
-
-                # Check HTTP status *after* attempting JSON parse
-                if response.is_success:  # 2xx
-                    logger.debug(
-                        f"DexScreener API success response status: {response.status_code}"
-                    )
-                    return response_data, None  # Success
-                else:  # 4xx/5xx
-                    logger.warning(
-                        f"DexScreener API returned error status: {response.status_code} - {response.text}"
-                    )
-                    error_details = {
-                        "error": "DexScreener API request failed",
-                        "error_type": "api_error",
-                        "status_code": response.status_code,
-                        "response_body": response_data,  # Parsed error body if available
-                        "url": url,
-                    }
-                    return None, error_details  # Return API error
-
-        except httpx.RequestError as req_err:
-            logger.error(
-                f"Request error connecting to DexScreener API: {req_err}", exc_info=True
-            )
-            error_details = {
-                "error": "Failed to connect to DexScreener API",
-                "error_type": "connection_error",
-                "details": str(req_err),
-                "url": url,
-            }
-            return None, error_details  # Return connection error
-
-        except Exception as e:
-            # Catch any other unexpected errors during the process
-            logger.exception(
-                f"An unexpected error occurred during DexScreener API GET call: {e}"
-            )
-            status_code = response.status_code if response else None
-            error_details = {
-                "error": "An unexpected error occurred during API call",
-                "error_type": "unexpected_error",
-                "status_code": status_code,  # Include if available
-                "details": str(e),
-                "url": url,
-            }
-            return None, error_details  # Return unexpected error
+import json
+import logging
+from typing import Any
+
+import httpx
+
+from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.dexscreener.utils import DEXSCREENER_BASE_URL
+
+logger = logging.getLogger(__name__)
+
+# ApiResult still represents (success_data, error_data)
+ApiResult = tuple[dict[str, Any] | None, dict[str, Any] | None]
+
+
+class DexScreenerBaseTool(IntentKitSkill):
+    """
+    Generic base class for tools interacting with the Dex Screener API.
+    Handles shared logic like API calls and error reporting via return values.
+    """
+
+    base_url: str = DEXSCREENER_BASE_URL
+
+    @property
+    def category(self) -> str:
+        return "dexscreener"
+
+    async def _get(
+        self,
+        path: str,
+        params: dict[str, Any] | None = None,
+    ) -> ApiResult:
+        """
+        Makes an asynchronous GET request to the DexScreener API.
+
+        Args:
+            path: The API endpoint path (e.g., "/dex/search").
+            params: Optional dictionary of query parameters.
+
+        Returns:
+            A tuple (data, error_details):
+            - (dict, None): On HTTP 2xx success with valid JSON response.
+            - (None, dict): On any error (API error, connection error,
+                            JSON parsing error, unexpected error). The dict
+                            contains details including an 'error_type'.
+        """
+        if not path.startswith("/"):
+            path = "/" + path
+
+        url = f"{self.base_url}{path}"
+        headers = {"Accept": "application/json"}
+        method = "GET"
+
+        logger.debug(f"Calling DexScreener API: {method} {url} with params: {params}")
+        response = None  # Define response outside try block for access in except
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.request(
+                    method, url, params=params, headers=headers
+                )
+
+                # Attempt to parse JSON response text
+                try:
+                    response_data = response.json()
+                except json.JSONDecodeError as json_err:
+                    logger.error(
+                        f"Failed to parse JSON response from {url}. Status: {response.status_code}. Response text: {response.text}",
+                        exc_info=True,
+                    )
+                    error_details = {
+                        "error": "Failed to parse DexScreener API response",
+                        "error_type": "parsing_error",
+                        "status_code": response.status_code,
+                        "details": response.text,  # Raw text causing the error
+                        "original_exception": str(json_err),
+                        "url": url,
+                    }
+                    return None, error_details  # Return parsing error
+
+                # Check HTTP status *after* attempting JSON parse
+                if response.is_success:  # 2xx
+                    logger.debug(
+                        f"DexScreener API success response status: {response.status_code}"
+                    )
+                    return response_data, None  # Success
+                else:  # 4xx/5xx
+                    logger.warning(
+                        f"DexScreener API returned error status: {response.status_code} - {response.text}"
+                    )
+                    error_details = {
+                        "error": "DexScreener API request failed",
+                        "error_type": "api_error",
+                        "status_code": response.status_code,
+                        "response_body": response_data,  # Parsed error body if available
+                        "url": url,
+                    }
+                    return None, error_details  # Return API error
+
+        except httpx.RequestError as req_err:
+            logger.error(
+                f"Request error connecting to DexScreener API: {req_err}", exc_info=True
+            )
+            error_details = {
+                "error": "Failed to connect to DexScreener API",
+                "error_type": "connection_error",
+                "details": str(req_err),
+                "url": url,
+            }
+            return None, error_details  # Return connection error
+
+        except Exception as e:
+            # Catch any other unexpected errors during the process
+            logger.exception(
+                f"An unexpected error occurred during DexScreener API GET call: {e}"
+            )
+            status_code = response.status_code if response else None
+            error_details = {
+                "error": "An unexpected error occurred during API call",
+                "error_type": "unexpected_error",
+                "status_code": status_code,  # Include if available
+                "details": str(e),
+                "url": url,
+            }
+            return None, error_details  # Return unexpected error

intentkit/skills/dexscreener/get_pair_info.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -39,7 +39,7 @@ class GetPairInfo(DexScreenerBaseTool):
         "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
+    args_schema: type[BaseModel] = GetPairInfoInput
 
     async def _arun(
         self,
@@ -50,10 +50,9 @@ class GetPairInfo(DexScreenerBaseTool):
         """Implementation to get specific pair information."""
 
         # Apply rate limiting
-        await self.user_rate_limit_by_category(
-            user_id=f"{self.category}{self.name}",
+        await self.global_rate_limit_by_skill(
             limit=RATE_LIMITS["pairs"],
-            minutes=1,
+            seconds=60,
         )
 
         logger.info(

intentkit/skills/dexscreener/get_token_pairs.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Type
+from typing import Any
 
 from pydantic import BaseModel, Field, ValidationError
 
@@ -44,7 +44,7 @@ class GetTokenPairs(DexScreenerBaseTool):
         "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
+    args_schema: type[BaseModel] = GetTokenPairsInput
 
     async def _arun(
         self,
@@ -55,10 +55,9 @@ class GetTokenPairs(DexScreenerBaseTool):
         """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}",
+        await self.global_rate_limit_by_skill(
             limit=RATE_LIMITS["token_pairs"],
-            minutes=1,
+            seconds=60,
         )
 
         logger.info(