intentkit 0.6.9.dev2__py3-none-any.whl → 0.6.10__py3-none-any.whl

intentkit/skills/carv/onchain_query.py

@@ -1,164 +1,162 @@
-import logging
-from decimal import Decimal, InvalidOperation
-from typing import Any, Dict, Literal, Type
-
-from langchain_core.runnables import RunnableConfig
-from pydantic import BaseModel, Field
-
-from intentkit.skills.carv.base import CarvBaseTool
-
-logger = logging.getLogger(__name__)
-
-
-class CarvInput(BaseModel):
-    """
-    Input schema for CARV SQL Query API.
-    Defines parameters controllable by the user when invoking the tool.
-    """
-
-    question: str = Field(
-        ...,
-        description="The question to query on-chain data.",
-    )
-    chain: Literal["ethereum", "base", "bitcoin", "solana"] = Field(
-        ...,
-        description="supported chain is ethereum, base, bitcoin, solana",
-    )
-
-
-class OnchainQueryTool(CarvBaseTool):
-    """
-    Tool for querying on-chain data using natural language via the CARV SQL Query API.
-
-    This tool allows you to ask questions about blockchain data in plain English, and it will return
-    the relevant information. Behind the scenes, it uses the CARV API to convert your question into a SQL query
-    and retrieve the results.
-
-    Supported Blockchains: Ethereum, Base, Bitcoin, and Solana.
-
-    If the question is about a blockchain other than the ones listed above, or is not a clear question, the
-    tool will return an error.
-    """
-
-    name: str = "carv_onchain_query"
-    description: str = (
-        "Query blockchain data from Ethereum, Base, Bitcoin, or Solana using natural language. "
-        "This tool provides access to detailed metrics including block information (timestamps, hashes, miners, gas used/limits), "
-        "transaction details (hashes, sender/receiver addresses, amounts, gas prices), and overall network utilization. "
-        "It supports aggregate analytics such as daily transaction counts, average gas prices, top wallet activity, and blockchain growth trends. "
-        "You can filter results by time range, address type, transaction value, and other parameters.\n\n"
-        "IMPORTANT Rules:\n"
-        "- Only Ethereum, Base, Bitcoin, and Solana are supported.\n"
-        "- Always infer the target blockchain from the user's query.\n"
-        "- If an unsupported blockchain is requested, clearly explain the limitation.\n"
-        "- Convert user input into a specific and actionable natural language query (e.g., "
-        '"What\'s the most active address on Ethereum over the past 24 hours?" or '
-        '"Show the largest ETH transaction in the last 30 days").\n'
-        "- Respond in clear, concise natural language using only the data returned by the tool.\n"
-        "- Avoid markdown or bullet points unless explicitly requested.\n"
-        "- ETH values are denominated in 18 decimals—consider 10^18 when interpreting amounts.\n"
-        "- Never fabricate or infer data beyond what the tool provides."
-    )
-    args_schema: Type[BaseModel] = CarvInput
-
-    async def _arun(
-        self,
-        question: str,
-        chain: str,
-        config: RunnableConfig = None,  # type: ignore
-        **kwargs: Any,
-    ) -> Dict[str, Any]:
-        """
-        Queries the CARV SQL Query API and returns the response.
-        """
-        context = self.context_from_config(config)
-        try:
-            await self.apply_rate_limit(context)
-
-            payload = {"question": question}
-
-            result, error = await self._call_carv_api(
-                context=context,
-                endpoint="/ai-agent-backend/sql_query_by_llm",
-                method="POST",
-                payload=payload,
-            )
-
-            if error is not None or result is None:
-                logger.error(f"Error returned from CARV API: {error}")
-                return {
-                    "error": True,
-                    "error_type": "APIError",
-                    "message": "Failed to fetch data from CARV API.",
-                    "details": error,
-                }
-
-            _normalize_unit(result, chain)
-            return {"success": True, **result}
-
-        except Exception as e:
-            logger.error(f"An unexpected error occurred: {e}", exc_info=True)
-            return {
-                "error": True,
-                "error_type": type(e).__name__,
-                "message": "An unexpected error occurred.",
-                "details": str(e),
-            }
-
-
-def _normalize_unit(response_data: Dict[str, Any], chain: str) -> None:
-    """
-    Normalizes the 'value' field in on-chain response data to a human-readable format.
-    Adds the corresponding token ticker after the value.
-
-    Supported chains:
-    - Ethereum: 10^18 -> ETH
-    - Base: 10^18 -> ETH
-    - Solana: 10^9 -> SOL
-    - Bitcoin: 10^8 -> BTC
-    """
-    column_infos = response_data.get("column_infos", [])
-    rows = response_data.get("rows", [])
-
-    if "value" not in column_infos:
-        return
-
-    value_index = column_infos.index("value")
-
-    chain = chain.lower()
-    if chain == "ethereum":
-        divisor = Decimal("1e18")
-        ticker = "ETH"
-    elif chain == "base":
-        divisor = Decimal("1e18")
-        ticker = "ETH"
-    elif chain == "solana":
-        divisor = Decimal("1e9")
-        ticker = "SOL"
-    elif chain == "bitcoin":
-        divisor = Decimal("1e8")
-        ticker = "BTC"
-    else:
-        logger.warning(f"Unsupported chain '{chain}' for unit normalization.")
-        return
-
-    for row in rows:
-        items = row.get("items", [])
-        if len(items) > value_index:
-            original_value = items[value_index]
-            try:
-                normalized = str(original_value).strip()
-                try:
-                    value_decimal = Decimal(normalized)
-                except InvalidOperation:
-                    value_decimal = Decimal.from_float(float(normalized))
-
-                converted = value_decimal / divisor
-                formatted_value = (
-                    format(converted, "f").rstrip("0").rstrip(".")
-                    if "." in format(converted, "f")
-                    else format(converted, "f")
-                )
-                items[value_index] = f"{formatted_value} {ticker}"
-            except Exception as e:
-                logger.warning(f"Unable to normalize value '{original_value}': {e}")
+import logging
+from decimal import Decimal, InvalidOperation
+from typing import Any, Dict, Literal, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.carv.base import CarvBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class CarvInput(BaseModel):
+    """
+    Input schema for CARV SQL Query API.
+    Defines parameters controllable by the user when invoking the tool.
+    """
+
+    question: str = Field(
+        ...,
+        description="The question to query on-chain data.",
+    )
+    chain: Literal["ethereum", "base", "bitcoin", "solana"] = Field(
+        ...,
+        description="supported chain is ethereum, base, bitcoin, solana",
+    )
+
+
+class OnchainQueryTool(CarvBaseTool):
+    """
+    Tool for querying on-chain data using natural language via the CARV SQL Query API.
+
+    This tool allows you to ask questions about blockchain data in plain English, and it will return
+    the relevant information. Behind the scenes, it uses the CARV API to convert your question into a SQL query
+    and retrieve the results.
+
+    Supported Blockchains: Ethereum, Base, Bitcoin, and Solana.
+
+    If the question is about a blockchain other than the ones listed above, or is not a clear question, the
+    tool will return an error.
+    """
+
+    name: str = "carv_onchain_query"
+    description: str = (
+        "Query blockchain data from Ethereum, Base, Bitcoin, or Solana using natural language. "
+        "This tool provides access to detailed metrics including block information (timestamps, hashes, miners, gas used/limits), "
+        "transaction details (hashes, sender/receiver addresses, amounts, gas prices), and overall network utilization. "
+        "It supports aggregate analytics such as daily transaction counts, average gas prices, top wallet activity, and blockchain growth trends. "
+        "You can filter results by time range, address type, transaction value, and other parameters.\n\n"
+        "IMPORTANT Rules:\n"
+        "- Only Ethereum, Base, Bitcoin, and Solana are supported.\n"
+        "- Always infer the target blockchain from the user's query.\n"
+        "- If an unsupported blockchain is requested, clearly explain the limitation.\n"
+        "- Convert user input into a specific and actionable natural language query (e.g., "
+        '"What\'s the most active address on Ethereum over the past 24 hours?" or '
+        '"Show the largest ETH transaction in the last 30 days").\n'
+        "- Respond in clear, concise natural language using only the data returned by the tool.\n"
+        "- Avoid markdown or bullet points unless explicitly requested.\n"
+        "- ETH values are denominated in 18 decimals—consider 10^18 when interpreting amounts.\n"
+        "- Never fabricate or infer data beyond what the tool provides."
+    )
+    args_schema: Type[BaseModel] = CarvInput
+
+    async def _arun(
+        self,
+        question: str,
+        chain: str,  # type: ignore
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """
+        Queries the CARV SQL Query API and returns the response.
+        """
+        context = self.get_context()
+        try:
+            await self.apply_rate_limit(context)
+
+            payload = {"question": question}
+
+            result, error = await self._call_carv_api(
+                context=context,
+                endpoint="/ai-agent-backend/sql_query_by_llm",
+                method="POST",
+                payload=payload,
+            )
+
+            if error is not None or result is None:
+                logger.error(f"Error returned from CARV API: {error}")
+                return {
+                    "error": True,
+                    "error_type": "APIError",
+                    "message": "Failed to fetch data from CARV API.",
+                    "details": error,
+                }
+
+            _normalize_unit(result, chain)
+            return {"success": True, **result}
+
+        except Exception as e:
+            logger.error(f"An unexpected error occurred: {e}", exc_info=True)
+            return {
+                "error": True,
+                "error_type": type(e).__name__,
+                "message": "An unexpected error occurred.",
+                "details": str(e),
+            }
+
+
+def _normalize_unit(response_data: Dict[str, Any], chain: str) -> None:
+    """
+    Normalizes the 'value' field in on-chain response data to a human-readable format.
+    Adds the corresponding token ticker after the value.
+
+    Supported chains:
+    - Ethereum: 10^18 -> ETH
+    - Base: 10^18 -> ETH
+    - Solana: 10^9 -> SOL
+    - Bitcoin: 10^8 -> BTC
+    """
+    column_infos = response_data.get("column_infos", [])
+    rows = response_data.get("rows", [])
+
+    if "value" not in column_infos:
+        return
+
+    value_index = column_infos.index("value")
+
+    chain = chain.lower()
+    if chain == "ethereum":
+        divisor = Decimal("1e18")
+        ticker = "ETH"
+    elif chain == "base":
+        divisor = Decimal("1e18")
+        ticker = "ETH"
+    elif chain == "solana":
+        divisor = Decimal("1e9")
+        ticker = "SOL"
+    elif chain == "bitcoin":
+        divisor = Decimal("1e8")
+        ticker = "BTC"
+    else:
+        logger.warning(f"Unsupported chain '{chain}' for unit normalization.")
+        return
+
+    for row in rows:
+        items = row.get("items", [])
+        if len(items) > value_index:
+            original_value = items[value_index]
+            try:
+                normalized = str(original_value).strip()
+                try:
+                    value_decimal = Decimal(normalized)
+                except InvalidOperation:
+                    value_decimal = Decimal.from_float(float(normalized))
+
+                converted = value_decimal / divisor
+                formatted_value = (
+                    format(converted, "f").rstrip("0").rstrip(".")
+                    if "." in format(converted, "f")
+                    else format(converted, "f")
+                )
+                items[value_index] = f"{formatted_value} {ticker}"
+            except Exception as e:
+                logger.warning(f"Unable to normalize value '{original_value}': {e}")

intentkit/skills/carv/token_info_and_price.py

@@ -1,110 +1,108 @@
-import logging
-import re
-from typing import Any, Dict, Optional, Type
-
-from langchain_core.runnables import RunnableConfig
-from pydantic import BaseModel, Field
-
-from intentkit.skills.carv.base import CarvBaseTool
-
-logger = logging.getLogger(__name__)
-
-
-class TokenInfoAndPriceInput(BaseModel):
-    ticker: str = Field(
-        description="The token's ticker symbol (e.g., 'eth', 'btc', 'sol', 'xrp')."
-    )
-    token_name: str = Field(
-        description="The token name (e.g ethereum, bitcoin, solana, ripple)"
-    )
-    amount: Optional[float] = Field(
-        description="(optional) amount of token, fill this if user asking for how much x amount of specific token worth"
-    )
-
-
-class TokenInfoAndPriceTool(CarvBaseTool):
-    """
-    Fetches detailed information and the current USD price of a cryptocurrency token from the CARV API,
-    given its ticker symbol (e.g., 'eth', 'btc', 'aave').
-    Returns metadata including the token's name, symbol, platform, category tags, and contract addresses
-    Useful for understanding a token's identity, ecosystem, and market valu
-    Use this tool when you need comprehensive token data and live pricing from CARV
-    """
-
-    name: str = "carv_token_info_and_price"
-    description: str = (
-        "Fetches detailed information and the current USD price of a cryptocurrency token from the CARV API, "
-        "given its ticker symbol (e.g., 'eth', 'btc', 'aave'). or token name"
-        "Returns metadata including the token's name, symbol, platform, category tags, and contract addresses "
-        "Useful for understanding a token's identity, ecosystem, and market value"
-        "Use this tool when you need comprehensive token data and live pricing from CARV."
-    )
-    args_schema: Type[BaseModel] = TokenInfoAndPriceInput
-
-    async def _arun(
-        self,
-        ticker: str,
-        token_name: str,
-        amount: Optional[float] = 1,
-        config: RunnableConfig = None,  # type: ignore
-        **kwargs: Any,
-    ) -> Dict[str, Any]:
-        if not ticker:
-            return {
-                "error": True,
-                "message": "ticker is null",
-                "suggestion": "ask the user for the specific ticker, and fill the `ticker` field when calling this tool",
-            }
-
-        context = self.context_from_config(config)
-        params = {"ticker": ticker}
-        path = "/ai-agent-backend/token_info"
-        method = "GET"
-
-        result, error = await self._call_carv_api(
-            context=context,
-            endpoint=path,
-            params=params,
-            method=method,
-        )
-
-        if error is not None or result is None:
-            logger.error(f"Error returned from CARV API: {error}")
-            return {
-                "error": True,
-                "error_type": "APIError",
-                "message": "Failed to fetch token info from CARV API.",
-                "details": error,
-            }
-
-        # retry with token_name if price is 0 or missing
-        if "price" not in result or result["price"] == 0:
-            fallback_ticker = re.sub(r"\s+", "-", token_name.strip().lower())
-            logger.info(
-                f"Fallback triggered. Trying with fallback ticker: {fallback_ticker}"
-            )
-
-            fallback_params = {"ticker": fallback_ticker}
-            result, error = await self._call_carv_api(
-                context=context,
-                endpoint=path,
-                params=fallback_params,
-                method=method,
-            )
-
-            if error is not None or result is None or result.get("price") == 0:
-                logger.error(f"Fallback error returned from CARV API: {error}")
-                return {
-                    "error": True,
-                    "error_type": "APIError",
-                    "message": "Failed to fetch token info from CARV API with fallback.",
-                    "details": error,
-                }
-
-        if "price" in result and amount is not None:
-            return {
-                "additional_info": f"{amount} {ticker.upper()} is worth ${round(amount * result['price'], 2)}",
-                **result,
-            }
-
-        return result
+import logging
+import re
+from typing import Any, Dict, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.carv.base import CarvBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class TokenInfoAndPriceInput(BaseModel):
+    ticker: str = Field(
+        description="The token's ticker symbol (e.g., 'eth', 'btc', 'sol', 'xrp')."
+    )
+    token_name: str = Field(
+        description="The token name (e.g ethereum, bitcoin, solana, ripple)"
+    )
+    amount: Optional[float] = Field(
+        description="(optional) amount of token, fill this if user asking for how much x amount of specific token worth"
+    )
+
+
+class TokenInfoAndPriceTool(CarvBaseTool):
+    """
+    Fetches detailed information and the current USD price of a cryptocurrency token from the CARV API,
+    given its ticker symbol (e.g., 'eth', 'btc', 'aave').
+    Returns metadata including the token's name, symbol, platform, category tags, and contract addresses
+    Useful for understanding a token's identity, ecosystem, and market valu
+    Use this tool when you need comprehensive token data and live pricing from CARV
+    """
+
+    name: str = "carv_token_info_and_price"
+    description: str = (
+        "Fetches detailed information and the current USD price of a cryptocurrency token from the CARV API, "
+        "given its ticker symbol (e.g., 'eth', 'btc', 'aave'). or token name"
+        "Returns metadata including the token's name, symbol, platform, category tags, and contract addresses "
+        "Useful for understanding a token's identity, ecosystem, and market value"
+        "Use this tool when you need comprehensive token data and live pricing from CARV."
+    )
+    args_schema: Type[BaseModel] = TokenInfoAndPriceInput
+
+    async def _arun(
+        self,
+        ticker: str,
+        token_name: str,
+        amount: Optional[float] = 1,  # type: ignore
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        if not ticker:
+            return {
+                "error": True,
+                "message": "ticker is null",
+                "suggestion": "ask the user for the specific ticker, and fill the `ticker` field when calling this tool",
+            }
+
+        context = self.get_context()
+        params = {"ticker": ticker}
+        path = "/ai-agent-backend/token_info"
+        method = "GET"
+
+        result, error = await self._call_carv_api(
+            context=context,
+            endpoint=path,
+            params=params,
+            method=method,
+        )
+
+        if error is not None or result is None:
+            logger.error(f"Error returned from CARV API: {error}")
+            return {
+                "error": True,
+                "error_type": "APIError",
+                "message": "Failed to fetch token info from CARV API.",
+                "details": error,
+            }
+
+        # retry with token_name if price is 0 or missing
+        if "price" not in result or result["price"] == 0:
+            fallback_ticker = re.sub(r"\s+", "-", token_name.strip().lower())
+            logger.info(
+                f"Fallback triggered. Trying with fallback ticker: {fallback_ticker}"
+            )
+
+            fallback_params = {"ticker": fallback_ticker}
+            result, error = await self._call_carv_api(
+                context=context,
+                endpoint=path,
+                params=fallback_params,
+                method=method,
+            )
+
+            if error is not None or result is None or result.get("price") == 0:
+                logger.error(f"Fallback error returned from CARV API: {error}")
+                return {
+                    "error": True,
+                    "error_type": "APIError",
+                    "message": "Failed to fetch token info from CARV API with fallback.",
+                    "details": error,
+                }
+
+        if "price" in result and amount is not None:
+            return {
+                "additional_info": f"{amount} {ticker.upper()} is worth ${round(amount * result['price'], 2)}",
+                **result,
+            }
+
+        return result

intentkit/skills/chainlist/chain_lookup.py

@@ -2,7 +2,6 @@ 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
@@ -160,7 +159,7 @@ class ChainLookup(ChainlistBaseTool):
         chain_id: Optional[int] = None,
         no_tracking: Optional[bool] = False,
         limit: Optional[int] = 5,
-        config: Optional[RunnableConfig] = None,
+        config: Optional[Any] = None,
         **kwargs,
     ) -> Dict:
         """Lookup blockchain RPC endpoints from Chainlist."""

intentkit/skills/common/current_time.py

@@ -3,7 +3,6 @@ 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
@@ -39,7 +38,7 @@ class CurrentTime(CommonBaseTool):
     )
     args_schema: Type[BaseModel] = CurrentTimeInput
 
-    async def _arun(self, timezone: str, config: RunnableConfig, **kwargs) -> str:
+    async def _arun(self, timezone: str, **kwargs) -> str:
         """Implementation of the tool to get the current time.
 
         Args:

intentkit/skills/cookiefun/base.py

@@ -1,7 +1,7 @@
 import logging
-from typing import Optional, Type
+from typing import Type
 
-from langchain_core.runnables import RunnableConfig
+from langchain.tools.base import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.abstracts.skill import SkillStoreABC
@@ -24,18 +24,26 @@ class CookieFunBaseTool(IntentKitSkill):
     def category(self) -> str:
         return "cookiefun"
 
-    def get_api_key(self, config: RunnableConfig) -> Optional[str]:
+    def get_api_key(self) -> str:
         """
         Get the API key from configuration.
 
-        Args:
-            config: The runnable configuration containing context
-
         Returns:
-            The API key or None if not configured
+            The API key
+
+        Raises:
+            ToolException: If the API key is not found or provider is invalid.
         """
-        context = self.context_from_config(config)
-        skill_config = context.config
-        if skill_config.get("api_key_provider") == "agent_owner":
-            return skill_config.get("api_key")
-        return self.skill_store.get_system_config("cookiefun_api_key")
+        context = self.get_context()
+        skill_config = context.agent.skill_config(self.category)
+        api_key_provider = skill_config.get("api_key_provider")
+        if api_key_provider == "agent_owner":
+            api_key = skill_config.get("api_key")
+            if api_key:
+                return api_key
+            else:
+                raise ToolException("No api_key found in agent_owner configuration")
+        else:
+            raise ToolException(
+                f"Invalid API key provider: {api_key_provider}. Only 'agent_owner' is supported for CookieFun."
+            )