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

intentkit/skills/carv/__init__.py

@@ -1,121 +1,115 @@
-import logging
-from typing import List, Literal, Optional, TypedDict
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import SkillConfig, SkillState
-from intentkit.skills.carv.base import CarvBaseTool
-from intentkit.skills.carv.fetch_news import FetchNewsTool
-from intentkit.skills.carv.onchain_query import OnchainQueryTool
-from intentkit.skills.carv.token_info_and_price import TokenInfoAndPriceTool
-
-logger = logging.getLogger(__name__)
-
-
-_cache: dict[str, CarvBaseTool] = {}
-
-_SKILL_NAME_TO_CLASS_MAP: dict[str, type[CarvBaseTool]] = {
-    "onchain_query": OnchainQueryTool,
-    "token_info_and_price": TokenInfoAndPriceTool,
-    "fetch_news": FetchNewsTool,
-}
-
-
-class SkillStates(TypedDict):
-    onchain_query: SkillState
-    token_info_and_price: SkillState
-    fetch_news: SkillState
-
-
-class Config(SkillConfig):
-    enabled: bool
-    states: SkillStates  # type: ignore
-    api_key_provider: Optional[Literal["agent_owner", "platform"]]
-
-    # conditionally required
-    api_key: Optional[str]
-
-    # optional
-    rate_limit_number: Optional[int]
-    rate_limit_minutes: Optional[int]
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,
-) -> list[CarvBaseTool]:
-    """
-    Factory function to create and return CARV skill tools based on the provided configuration.
-
-    Args:
-        config: The configuration object for the CARV skill.
-        is_private: A boolean indicating whether the request is from a private context.
-        store: An instance of `SkillStoreABC`.
-
-    Returns:
-        A list of `CarvBaseTool` instances.
-    """
-    # Check if the entire category is disabled first
-    if not config.get("enabled", False):
-        return []
-
-    available_skills: List[CarvBaseTool] = []
-    skill_states = config.get("states", {})
-
-    # Iterate through all known skills defined in the map
-    for skill_name in _SKILL_NAME_TO_CLASS_MAP:
-        state = skill_states.get(
-            skill_name, "disabled"
-        )  # Default to disabled if not in config
-
-        if state == "disabled":
-            continue
-        elif state == "public" or (state == "private" and is_private):
-            # If enabled, get the skill instance using the factory function
-            skill_instance = get_carv_skill(skill_name, store)
-            if skill_instance:
-                available_skills.append(skill_instance)
-            else:
-                logger.warning(f"Could not instantiate known skill: {skill_name}")
-
-    return available_skills
-
-
-def get_carv_skill(
-    name: str,
-    store: SkillStoreABC,
-) -> Optional[CarvBaseTool]:
-    """
-    Factory function to retrieve a cached CARV skill instance by name.
-
-    Args:
-        name: The name of the CARV skill to retrieve.
-        store: An instance of `SkillStoreABC`.
-
-    Returns:
-        The requested `CarvBaseTool` instance if found and enabled, otherwise None.
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    # Get the class from the map
-    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
-
-    if skill_class:
-        try:
-            # Instantiate the skill and add to cache
-            instance = skill_class(skill_store=store)  # type: ignore
-            _cache[name] = instance
-            return instance
-        except Exception as e:
-            logger.error(
-                f"Failed to instantiate Carv skill '{name}': {e}", exc_info=True
-            )
-            return None  # Failed to instantiate
-    else:
-        # This handles cases where a name might be in config but not in our map
-        logger.warning(f"Attempted to get unknown Carv skill: {name}")
-        return None
+import logging
+from typing import Literal, TypedDict
+
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.carv.base import CarvBaseTool
+from intentkit.skills.carv.fetch_news import FetchNewsTool
+from intentkit.skills.carv.onchain_query import OnchainQueryTool
+from intentkit.skills.carv.token_info_and_price import TokenInfoAndPriceTool
+
+logger = logging.getLogger(__name__)
+
+_cache: dict[str, CarvBaseTool] = {}
+
+_SKILL_NAME_TO_CLASS_MAP: dict[str, type[CarvBaseTool]] = {
+    "onchain_query": OnchainQueryTool,
+    "token_info_and_price": TokenInfoAndPriceTool,
+    "fetch_news": FetchNewsTool,
+}
+
+
+class SkillStates(TypedDict):
+    onchain_query: SkillState
+    token_info_and_price: SkillState
+    fetch_news: SkillState
+
+
+class Config(SkillConfig):
+    enabled: bool
+    states: SkillStates  # type: ignore
+    api_key_provider: Literal["agent_owner", "platform"] | None
+
+    # conditionally required
+    api_key: str | None
+
+    # optional
+    rate_limit_number: int | None
+    rate_limit_minutes: int | None
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,
+) -> list[CarvBaseTool]:
+    """
+    Factory function to create and return CARV skill tools based on the provided configuration.
+
+    Args:
+        config: The configuration object for the CARV skill.
+        is_private: A boolean indicating whether the request is from a private context.
+
+    Returns:
+        A list of `CarvBaseTool` instances.
+    """
+    # Check if the entire category is disabled first
+    if not config.get("enabled", False):
+        return []
+
+    available_skills: list[CarvBaseTool] = []
+    skill_states = config.get("states", {})
+
+    # Iterate through all known skills defined in the map
+    for skill_name in _SKILL_NAME_TO_CLASS_MAP:
+        state = skill_states.get(
+            skill_name, "disabled"
+        )  # Default to disabled if not in config
+
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            # If enabled, get the skill instance using the factory function
+            skill_instance = get_carv_skill(skill_name)
+            if skill_instance:
+                available_skills.append(skill_instance)
+            else:
+                logger.warning(f"Could not instantiate known skill: {skill_name}")
+
+    return available_skills
+
+
+def get_carv_skill(
+    name: str,
+) -> CarvBaseTool | None:
+    """
+    Factory function to retrieve a cached CARV skill instance by name.
+
+    Args:
+        name: The name of the CARV skill to retrieve.
+
+    Returns:
+        The requested `CarvBaseTool` instance if found and enabled, otherwise None.
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    # Get the class from the map
+    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
+
+    if skill_class:
+        try:
+            # Instantiate the skill and add to cache
+            instance = skill_class()  # type: ignore
+            _cache[name] = instance
+            return instance
+        except Exception as e:
+            logger.error(
+                f"Failed to instantiate Carv skill '{name}': {e}", exc_info=True
+            )
+            return None  # Failed to instantiate
+    else:
+        # This handles cases where a name might be in config but not in our map
+        logger.warning(f"Attempted to get unknown Carv skill: {name}")
+        return None

intentkit/skills/carv/base.py

@@ -1,185 +1,184 @@
-import logging
-from typing import Any, Dict, Optional, Tuple, Type
-
-import httpx  # Ensure httpx is installed: pip install httpx
-from langchain.tools.base import ToolException
-from pydantic import BaseModel, Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import IntentKitSkill
-
-logger = logging.getLogger(__name__)
-
-CARV_API_BASE_URL = "https://interface.carv.io"
-
-
-class CarvBaseTool(IntentKitSkill):
-    """Base class for CARV API tools."""
-
-    name: str = Field(description="Tool name")  # type: ignore
-    description: str = Field(description="Tool description")
-    args_schema: Type[BaseModel]  # type: ignore
-    skill_store: SkillStoreABC = Field(description="Skill store for data persistence")
-
-    @property
-    def category(self) -> str:
-        return "carv"
-
-    def get_api_key(self) -> str:
-        """
-        Retrieves the CARV API key based on the api_key_provider setting.
-
-        Returns:
-            The API key if found.
-
-        Raises:
-            ToolException: If the API key is not found or provider is invalid.
-        """
-        try:
-            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":
-                agent_api_key: Optional[str] = skill_config.get("api_key")
-                if agent_api_key:
-                    logger.debug(
-                        f"Using agent-specific CARV API key for skill {self.name} in category {self.category}"
-                    )
-                    return agent_api_key
-                raise ToolException(
-                    f"No agent-owned CARV API key found for skill '{self.name}' in category '{self.category}'."
-                )
-
-            elif api_key_provider == "platform":
-                system_api_key = self.skill_store.get_system_config("carv_api_key")
-                if system_api_key:
-                    logger.debug(
-                        f"Using system CARV API key for skill {self.name} in category {self.category}"
-                    )
-                    return system_api_key
-                raise ToolException(
-                    f"No platform-hosted CARV API key found for skill '{self.name}' in category '{self.category}'."
-                )
-
-            else:
-                raise ToolException(
-                    f"Invalid API key provider '{api_key_provider}' for skill '{self.name}'"
-                )
-
-        except Exception as e:
-            # Re-raise ToolException if it's already one, otherwise wrap
-            if isinstance(e, ToolException):
-                raise
-            raise ToolException(f"Failed to retrieve CARV API key: {str(e)}") from e
-
-    async def apply_rate_limit(self, context) -> None:
-        """
-        Applies rate limiting ONLY if specified in the agent's config ('skill_config').
-        Checks for 'rate_limit_number' and 'rate_limit_minutes'.
-        If not configured, NO rate limiting is applied.
-        Raises ConnectionAbortedError if the configured limit is exceeded.
-        """
-        skill_config = context.agent.skill_config(self.category)
-        user_id = context.agent.id
-
-        limit_num = skill_config.get("rate_limit_number")
-        limit_min = skill_config.get("rate_limit_minutes")
-
-        # Apply limit ONLY if both values are present and valid (truthy check handles None and 0)
-        if limit_num and limit_min:
-            logger.debug(
-                f"Applying rate limit ({limit_num}/{limit_min} min) for user {user_id} on {self.name}"
-            )
-            if user_id:
-                await self.user_rate_limit_by_category(user_id, limit_num, limit_min)
-        else:
-            # No valid agent configuration found, so do nothing.
-            logger.debug(
-                f"No agent rate limits configured for category '{self.category}'. Skipping rate limit for user {user_id}."
-            )
-
-    async def _call_carv_api(
-        self,
-        context,
-        endpoint: str,
-        method: str = "GET",
-        params: Optional[Dict[str, Any]] = None,
-        payload: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
-        """
-        Makes a call to the CARV API and returns a tuple of (success, error).
-
-        Args:
-            context: The skill context.
-            endpoint: The API endpoint path (e.g., "/ai-agent-backend/token_info").
-            method: HTTP method ("GET", "POST", etc.).
-            params: Query parameters for the request.
-            payload: JSON payload for POST/PUT requests.
-
-        Returns:
-            Tuple where the first element is the response data if successful,
-            and the second element is an error dict if an error occurred.
-        """
-
-        url = f"{CARV_API_BASE_URL}{endpoint}"
-
-        try:
-            api_key = self.get_api_key()
-
-            headers = {
-                "Authorization": api_key,
-                "Content-Type": "application/json",
-            }
-
-            logger.debug(
-                f"Calling CARV API: {method} {url} with params {params}, payload {payload}"
-            )
-
-            async with httpx.AsyncClient(timeout=30.0) as client:
-                if method == "GET":
-                    response = await client.get(url, headers=headers, params=params)
-                elif method == "POST":
-                    response = await client.post(
-                        url, headers=headers, json=payload, params=params
-                    )
-                else:
-                    return None, {"error": f"Unsupported HTTP method: {method}"}
-
-                # Do NOT raise for status here; always parse JSON
-                try:
-                    response_json: dict[str, Any] = response.json()
-                except Exception as json_err:
-                    err_msg = f"Failed to parse JSON response: {json_err}"
-                    logger.error(err_msg)
-                    return None, {"error": err_msg}
-
-                logger.debug(
-                    f"CARV API Response (status {response.status_code}): {response_json}"
-                )
-
-                # Check if response_json signals an error explicitly (custom API error)
-                if response.status_code >= 400 or "error" in response_json:
-                    # Return full error info (including status code, body, etc.)
-                    return None, {
-                        "error": response_json.get("error", "Unknown API error"),
-                        "status_code": response.status_code,
-                        "response": response_json,
-                        "url": url,
-                        "method": method,
-                        "params": params,
-                        "payload": payload,
-                    }
-
-                # Otherwise return the 'data' field if present, else full response
-                return response_json.get("data", response_json), None
-
-        except Exception as e:
-            logger.error(
-                f"Error calling CARV API to {method} > {url}: {e}", exc_info=True
-            )
-            return None, {
-                "error": str(e),
-                "url": url,
-                "method": method,
-                "params": params,
-            }
+import logging
+from typing import Any
+
+import httpx  # Ensure httpx is installed: pip install httpx
+from langchain_core.tools.base import ToolException
+from pydantic import BaseModel, Field
+
+from intentkit.config.config import config
+from intentkit.skills.base import IntentKitSkill
+
+logger = logging.getLogger(__name__)
+
+CARV_API_BASE_URL = "https://interface.carv.io"
+
+
+class CarvBaseTool(IntentKitSkill):
+    """Base class for CARV API tools."""
+
+    name: str = Field(description="Tool name")  # type: ignore
+    description: str = Field(description="Tool description")
+    args_schema: type[BaseModel]  # type: ignore
+
+    @property
+    def category(self) -> str:
+        return "carv"
+
+    def get_api_key(self) -> str:
+        """
+        Retrieves the CARV API key based on the api_key_provider setting.
+
+        Returns:
+            The API key if found.
+
+        Raises:
+            ToolException: If the API key is not found or provider is invalid.
+        """
+        try:
+            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":
+                agent_api_key: str | None = skill_config.get("api_key")
+                if agent_api_key:
+                    logger.debug(
+                        f"Using agent-specific CARV API key for skill {self.name} in category {self.category}"
+                    )
+                    return agent_api_key
+                raise ToolException(
+                    f"No agent-owned CARV API key found for skill '{self.name}' in category '{self.category}'."
+                )
+
+            elif api_key_provider == "platform":
+                system_api_key = config.carv_api_key
+                if system_api_key:
+                    logger.debug(
+                        f"Using system CARV API key for skill {self.name} in category {self.category}"
+                    )
+                    return system_api_key
+                raise ToolException(
+                    f"No platform-hosted CARV API key found for skill '{self.name}' in category '{self.category}'."
+                )
+
+            else:
+                raise ToolException(
+                    f"Invalid API key provider '{api_key_provider}' for skill '{self.name}'"
+                )
+
+        except Exception as e:
+            # Re-raise ToolException if it's already one, otherwise wrap
+            if isinstance(e, ToolException):
+                raise
+            raise ToolException(f"Failed to retrieve CARV API key: {str(e)}") from e
+
+    async def apply_rate_limit(self, context) -> None:
+        """
+        Applies rate limiting ONLY if specified in the agent's config ('skill_config').
+        Checks for 'rate_limit_number' and 'rate_limit_minutes'.
+        If not configured, NO rate limiting is applied.
+        Raises ConnectionAbortedError if the configured limit is exceeded.
+        """
+        skill_config = context.agent.skill_config(self.category)
+        user_id = context.agent.id
+
+        limit_num = skill_config.get("rate_limit_number")
+        limit_min = skill_config.get("rate_limit_minutes")
+
+        # Apply limit ONLY if both values are present and valid (truthy check handles None and 0)
+        if limit_num and limit_min:
+            logger.debug(
+                f"Applying rate limit ({limit_num}/{limit_min} min) for user {user_id} on {self.name}"
+            )
+            if user_id:
+                await self.user_rate_limit_by_category(limit_num, limit_min * 60)
+        else:
+            # No valid agent configuration found, so do nothing.
+            logger.debug(
+                f"No agent rate limits configured for category '{self.category}'. Skipping rate limit for user {user_id}."
+            )
+
+    async def _call_carv_api(
+        self,
+        context,
+        endpoint: str,
+        method: str = "GET",
+        params: dict[str, Any] | None = None,
+        payload: dict[str, Any] | None = None,
+    ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+        """
+        Makes a call to the CARV API and returns a tuple of (success, error).
+
+        Args:
+            context: The skill context.
+            endpoint: The API endpoint path (e.g., "/ai-agent-backend/token_info").
+            method: HTTP method ("GET", "POST", etc.).
+            params: Query parameters for the request.
+            payload: JSON payload for POST/PUT requests.
+
+        Returns:
+            Tuple where the first element is the response data if successful,
+            and the second element is an error dict if an error occurred.
+        """
+
+        url = f"{CARV_API_BASE_URL}{endpoint}"
+
+        try:
+            api_key = self.get_api_key()
+
+            headers = {
+                "Authorization": api_key,
+                "Content-Type": "application/json",
+            }
+
+            logger.debug(
+                f"Calling CARV API: {method} {url} with params {params}, payload {payload}"
+            )
+
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                if method == "GET":
+                    response = await client.get(url, headers=headers, params=params)
+                elif method == "POST":
+                    response = await client.post(
+                        url, headers=headers, json=payload, params=params
+                    )
+                else:
+                    return None, {"error": f"Unsupported HTTP method: {method}"}
+
+                # Do NOT raise for status here; always parse JSON
+                try:
+                    response_json: dict[str, Any] = response.json()
+                except Exception as json_err:
+                    err_msg = f"Failed to parse JSON response: {json_err}"
+                    logger.error(err_msg)
+                    return None, {"error": err_msg}
+
+                logger.debug(
+                    f"CARV API Response (status {response.status_code}): {response_json}"
+                )
+
+                # Check if response_json signals an error explicitly (custom API error)
+                if response.status_code >= 400 or "error" in response_json:
+                    # Return full error info (including status code, body, etc.)
+                    return None, {
+                        "error": response_json.get("error", "Unknown API error"),
+                        "status_code": response.status_code,
+                        "response": response_json,
+                        "url": url,
+                        "method": method,
+                        "params": params,
+                        "payload": payload,
+                    }
+
+                # Otherwise return the 'data' field if present, else full response
+                return response_json.get("data", response_json), None
+
+        except Exception as e:
+            logger.error(
+                f"Error calling CARV API to {method} > {url}: {e}", exc_info=True
+            )
+            return None, {
+                "error": str(e),
+                "url": url,
+                "method": method,
+                "params": params,
+            }

intentkit/skills/carv/fetch_news.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, Type
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -29,12 +29,12 @@ class FetchNewsTool(CarvBaseTool):
         "Fetches the latest news articles from the CARV API. "
         "Returns a list of news items, each with a title, URL, and a short summary (card_text)."
     )
-    args_schema: Type[BaseModel] = CarvNewsInput
+    args_schema: type[BaseModel] = CarvNewsInput
 
     async def _arun(
         self,  # type: ignore
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         Fetches news from the CARV API and returns the response.
         The expected successful response structure is a dictionary containing an "infos" key,