intentkit 0.8.11__py3-none-any.whl → 0.8.12__py3-none-any.whl

intentkit/skills/defillama/stablecoins/fetch_stablecoin_charts.py

@@ -69,9 +69,9 @@ class DefiLlamaFetchStablecoinCharts(DefiLlamaBaseTool):
 
     Example:
         charts_tool = DefiLlamaFetchStablecoinCharts(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         # Get all chains data
         result = await charts_tool._arun(stablecoin_id="1")

intentkit/skills/defillama/stablecoins/fetch_stablecoin_prices.py

@@ -42,9 +42,9 @@ class DefiLlamaFetchStablecoinPrices(DefiLlamaBaseTool):
 
     Example:
         prices_tool = DefiLlamaFetchStablecoinPrices(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await prices_tool._arun()
     """

intentkit/skills/defillama/stablecoins/fetch_stablecoins.py

@@ -87,9 +87,9 @@ class DefiLlamaFetchStablecoins(DefiLlamaBaseTool):
 
     Example:
         stablecoins_tool = DefiLlamaFetchStablecoins(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await stablecoins_tool._arun()
     """

intentkit/skills/defillama/tvl/fetch_chain_historical_tvl.py

@@ -48,9 +48,9 @@ class DefiLlamaFetchChainHistoricalTvl(DefiLlamaBaseTool):
 
     Example:
         tvl_tool = DefiLlamaFetchChainHistoricalTvl(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await tvl_tool._arun(chain="ethereum")
     """

intentkit/skills/defillama/tvl/fetch_chains.py

@@ -63,9 +63,9 @@ class DefiLlamaFetchChains(DefiLlamaBaseTool):
 
     Example:
         chains_tool = DefiLlamaFetchChains(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await chains_tool._arun()
     """

intentkit/skills/defillama/tvl/fetch_historical_tvl.py

@@ -50,9 +50,9 @@ class DefiLlamaFetchHistoricalTvl(DefiLlamaBaseTool):
 
     Example:
         tvl_tool = DefiLlamaFetchHistoricalTvl(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await tvl_tool._arun()
     """

intentkit/skills/defillama/tvl/fetch_protocol.py

@@ -144,9 +144,9 @@ class DefiLlamaFetchProtocol(DefiLlamaBaseTool):
 
     Example:
         protocol_tool = DefiLlamaFetchProtocol(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await protocol_tool._arun(protocol="aave")
     """

intentkit/skills/defillama/tvl/fetch_protocol_current_tvl.py

@@ -38,9 +38,9 @@ class DefiLlamaFetchProtocolCurrentTvl(DefiLlamaBaseTool):
 
     Example:
         tvl_tool = DefiLlamaFetchProtocolCurrentTvl(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await tvl_tool._arun(protocol="aave")
     """

intentkit/skills/defillama/tvl/fetch_protocols.py

@@ -128,9 +128,9 @@ class DefiLlamaFetchProtocols(DefiLlamaBaseTool):
 
     Example:
         protocols_tool = DefiLlamaFetchProtocols(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await protocols_tool._arun()
     """

intentkit/skills/defillama/volumes/fetch_dex_overview.py

@@ -118,9 +118,9 @@ class DefiLlamaFetchDexOverview(DefiLlamaBaseTool):
 
     Example:
         overview_tool = DefiLlamaFetchDexOverview(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await overview_tool._arun()
     """

intentkit/skills/defillama/volumes/fetch_dex_summary.py

@@ -78,9 +78,9 @@ class DefiLlamaFetchDexSummary(DefiLlamaBaseTool):
 
     Example:
         summary_tool = DefiLlamaFetchDexSummary(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await summary_tool._arun(protocol="uniswap")
     """

intentkit/skills/defillama/volumes/fetch_options_overview.py

@@ -86,9 +86,9 @@ class DefiLlamaFetchOptionsOverview(DefiLlamaBaseTool):
 
     Example:
         overview_tool = DefiLlamaFetchOptionsOverview(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await overview_tool._arun()
     """

intentkit/skills/defillama/yields/fetch_pool_chart.py

@@ -54,9 +54,9 @@ class DefiLlamaFetchPoolChart(DefiLlamaBaseTool):
 
     Example:
         chart_tool = DefiLlamaFetchPoolChart(
-            skill_store=store,
+            ,
             agent_id="agent_123",
-            agent_store=agent_store
+            agent=agent
         )
         result = await chart_tool._arun(
             pool_id="747c1d2a-c668-4682-b9f9-296708a3dd90"

intentkit/skills/defillama/yields/fetch_pools.py

@@ -87,9 +87,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 Optional, 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,
+) -> Optional[DexScreenerBaseTool]:
+    """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, Dict, Optional, Tuple
+
+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[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.
+    """
+
+    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